Index: common/src/java/org/apache/hadoop/hive/conf/HiveConf.java =================================================================== --- common/src/java/org/apache/hadoop/hive/conf/HiveConf.java (revision 1448321) +++ common/src/java/org/apache/hadoop/hive/conf/HiveConf.java (working copy) @@ -128,6 +128,7 @@ HiveConf.ConfVars.HMSHANDLERATTEMPTS, HiveConf.ConfVars.HMSHANDLERINTERVAL, HiveConf.ConfVars.HMSHANDLERFORCERELOADCONF, + HiveConf.ConfVars.METASTORE_PARTITION_NAME_WHITELIST_PATTERN }; /** Index: conf/hive-default.xml.template =================================================================== --- conf/hive-default.xml.template (revision 1448321) +++ conf/hive-default.xml.template (working copy) @@ -286,7 +286,7 @@ hive.metastore.partition.name.whitelist.pattern - Partition names will be checked against this regex pattern and rejected if not matched. To use, enable hive.metastore.pre.event.listeners=org.apache.hadoop.hive.metastore.PartitionNameWhitelistPreEventListener Listener will not register if this property value is empty. + Partition names will be checked against this regex pattern and rejected if not matched. Index: metastore/if/hive_metastore.thrift =================================================================== --- metastore/if/hive_metastore.thrift (revision 1448321) +++ metastore/if/hive_metastore.thrift (working copy) @@ -514,6 +514,11 @@ void rename_partition(1:string db_name, 2:string tbl_name, 3:list part_vals, 4:Partition new_part) throws (1:InvalidOperationException o1, 2:MetaException o2) + // returns whether or not the partition name is valid based on the value of the config + // hive.metastore.partition.name.whitelist.pattern + bool partition_name_has_valid_characters(1:list part_vals, 2:bool throw_exception) + throws(1: MetaException o1) + // gets the value of the configuration key in the metastore server. returns // defaultValue if the key does not exist. if the configuration key does not // begin with "hive", "mapred", or "hdfs", a ConfigValSecurityException is Index: metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp =================================================================== --- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (revision 1448321) +++ metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (working copy) @@ -12300,6 +12300,232 @@ return xfer; } +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::apache::thrift::protocol::TProtocol* 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->part_vals.clear(); + uint32_t _size511; + ::apache::thrift::protocol::TType _etype514; + xfer += iprot->readListBegin(_etype514, _size511); + this->part_vals.resize(_size511); + uint32_t _i515; + for (_i515 = 0; _i515 < _size511; ++_i515) + { + xfer += iprot->readString(this->part_vals[_i515]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->throw_exception); + this->__isset.throw_exception = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_has_valid_characters_args"); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); + std::vector ::const_iterator _iter516; + for (_iter516 = this->part_vals.begin(); _iter516 != this->part_vals.end(); ++_iter516) + { + xfer += oprot->writeString((*_iter516)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("throw_exception", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->throw_exception); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_has_valid_characters_pargs"); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); + std::vector ::const_iterator _iter517; + for (_iter517 = (*(this->part_vals)).begin(); _iter517 != (*(this->part_vals)).end(); ++_iter517) + { + xfer += oprot->writeString((*_iter517)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("throw_exception", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool((*(this->throw_exception))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_result::read(::apache::thrift::protocol::TProtocol* 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_BOOL) { + xfer += iprot->readBool(this->success); + 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_partition_name_has_valid_characters_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_partition_name_has_valid_characters_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + 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; +} + +uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_presult::read(::apache::thrift::protocol::TProtocol* 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_BOOL) { + xfer += iprot->readBool((*(this->success))); + 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_config_value_args::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t xfer = 0; @@ -12588,14 +12814,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size511; - ::apache::thrift::protocol::TType _etype514; - xfer += iprot->readListBegin(_etype514, _size511); - this->success.resize(_size511); - uint32_t _i515; - for (_i515 = 0; _i515 < _size511; ++_i515) + uint32_t _size518; + ::apache::thrift::protocol::TType _etype521; + xfer += iprot->readListBegin(_etype521, _size518); + this->success.resize(_size518); + uint32_t _i522; + for (_i522 = 0; _i522 < _size518; ++_i522) { - xfer += iprot->readString(this->success[_i515]); + xfer += iprot->readString(this->success[_i522]); } xfer += iprot->readListEnd(); } @@ -12634,10 +12860,10 @@ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter516; - for (_iter516 = this->success.begin(); _iter516 != this->success.end(); ++_iter516) + std::vector ::const_iterator _iter523; + for (_iter523 = this->success.begin(); _iter523 != this->success.end(); ++_iter523) { - xfer += oprot->writeString((*_iter516)); + xfer += oprot->writeString((*_iter523)); } xfer += oprot->writeListEnd(); } @@ -12676,14 +12902,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size517; - ::apache::thrift::protocol::TType _etype520; - xfer += iprot->readListBegin(_etype520, _size517); - (*(this->success)).resize(_size517); - uint32_t _i521; - for (_i521 = 0; _i521 < _size517; ++_i521) + uint32_t _size524; + ::apache::thrift::protocol::TType _etype527; + xfer += iprot->readListBegin(_etype527, _size524); + (*(this->success)).resize(_size524); + uint32_t _i528; + for (_i528 = 0; _i528 < _size524; ++_i528) { - xfer += iprot->readString((*(this->success))[_i521]); + xfer += iprot->readString((*(this->success))[_i528]); } xfer += iprot->readListEnd(); } @@ -12802,17 +13028,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size522; - ::apache::thrift::protocol::TType _ktype523; - ::apache::thrift::protocol::TType _vtype524; - xfer += iprot->readMapBegin(_ktype523, _vtype524, _size522); - uint32_t _i526; - for (_i526 = 0; _i526 < _size522; ++_i526) + uint32_t _size529; + ::apache::thrift::protocol::TType _ktype530; + ::apache::thrift::protocol::TType _vtype531; + xfer += iprot->readMapBegin(_ktype530, _vtype531, _size529); + uint32_t _i533; + for (_i533 = 0; _i533 < _size529; ++_i533) { - std::string _key527; - xfer += iprot->readString(_key527); - std::string& _val528 = this->success[_key527]; - xfer += iprot->readString(_val528); + std::string _key534; + xfer += iprot->readString(_key534); + std::string& _val535 = this->success[_key534]; + xfer += iprot->readString(_val535); } xfer += iprot->readMapEnd(); } @@ -12851,11 +13077,11 @@ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::map ::const_iterator _iter529; - for (_iter529 = this->success.begin(); _iter529 != this->success.end(); ++_iter529) + std::map ::const_iterator _iter536; + for (_iter536 = this->success.begin(); _iter536 != this->success.end(); ++_iter536) { - xfer += oprot->writeString(_iter529->first); - xfer += oprot->writeString(_iter529->second); + xfer += oprot->writeString(_iter536->first); + xfer += oprot->writeString(_iter536->second); } xfer += oprot->writeMapEnd(); } @@ -12894,17 +13120,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size530; - ::apache::thrift::protocol::TType _ktype531; - ::apache::thrift::protocol::TType _vtype532; - xfer += iprot->readMapBegin(_ktype531, _vtype532, _size530); - uint32_t _i534; - for (_i534 = 0; _i534 < _size530; ++_i534) + uint32_t _size537; + ::apache::thrift::protocol::TType _ktype538; + ::apache::thrift::protocol::TType _vtype539; + xfer += iprot->readMapBegin(_ktype538, _vtype539, _size537); + uint32_t _i541; + for (_i541 = 0; _i541 < _size537; ++_i541) { - std::string _key535; - xfer += iprot->readString(_key535); - std::string& _val536 = (*(this->success))[_key535]; - xfer += iprot->readString(_val536); + std::string _key542; + xfer += iprot->readString(_key542); + std::string& _val543 = (*(this->success))[_key542]; + xfer += iprot->readString(_val543); } xfer += iprot->readMapEnd(); } @@ -12973,17 +13199,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size537; - ::apache::thrift::protocol::TType _ktype538; - ::apache::thrift::protocol::TType _vtype539; - xfer += iprot->readMapBegin(_ktype538, _vtype539, _size537); - uint32_t _i541; - for (_i541 = 0; _i541 < _size537; ++_i541) + uint32_t _size544; + ::apache::thrift::protocol::TType _ktype545; + ::apache::thrift::protocol::TType _vtype546; + xfer += iprot->readMapBegin(_ktype545, _vtype546, _size544); + uint32_t _i548; + for (_i548 = 0; _i548 < _size544; ++_i548) { - std::string _key542; - xfer += iprot->readString(_key542); - std::string& _val543 = this->part_vals[_key542]; - xfer += iprot->readString(_val543); + std::string _key549; + xfer += iprot->readString(_key549); + std::string& _val550 = this->part_vals[_key549]; + xfer += iprot->readString(_val550); } xfer += iprot->readMapEnd(); } @@ -12994,9 +13220,9 @@ break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast544; - xfer += iprot->readI32(ecast544); - this->eventType = (PartitionEventType::type)ecast544; + int32_t ecast551; + xfer += iprot->readI32(ecast551); + this->eventType = (PartitionEventType::type)ecast551; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -13029,11 +13255,11 @@ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter545; - for (_iter545 = this->part_vals.begin(); _iter545 != this->part_vals.end(); ++_iter545) + std::map ::const_iterator _iter552; + for (_iter552 = this->part_vals.begin(); _iter552 != this->part_vals.end(); ++_iter552) { - xfer += oprot->writeString(_iter545->first); - xfer += oprot->writeString(_iter545->second); + xfer += oprot->writeString(_iter552->first); + xfer += oprot->writeString(_iter552->second); } xfer += oprot->writeMapEnd(); } @@ -13063,11 +13289,11 @@ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter546; - for (_iter546 = (*(this->part_vals)).begin(); _iter546 != (*(this->part_vals)).end(); ++_iter546) + std::map ::const_iterator _iter553; + for (_iter553 = (*(this->part_vals)).begin(); _iter553 != (*(this->part_vals)).end(); ++_iter553) { - xfer += oprot->writeString(_iter546->first); - xfer += oprot->writeString(_iter546->second); + xfer += oprot->writeString(_iter553->first); + xfer += oprot->writeString(_iter553->second); } xfer += oprot->writeMapEnd(); } @@ -13318,17 +13544,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size547; - ::apache::thrift::protocol::TType _ktype548; - ::apache::thrift::protocol::TType _vtype549; - xfer += iprot->readMapBegin(_ktype548, _vtype549, _size547); - uint32_t _i551; - for (_i551 = 0; _i551 < _size547; ++_i551) + uint32_t _size554; + ::apache::thrift::protocol::TType _ktype555; + ::apache::thrift::protocol::TType _vtype556; + xfer += iprot->readMapBegin(_ktype555, _vtype556, _size554); + uint32_t _i558; + for (_i558 = 0; _i558 < _size554; ++_i558) { - std::string _key552; - xfer += iprot->readString(_key552); - std::string& _val553 = this->part_vals[_key552]; - xfer += iprot->readString(_val553); + std::string _key559; + xfer += iprot->readString(_key559); + std::string& _val560 = this->part_vals[_key559]; + xfer += iprot->readString(_val560); } xfer += iprot->readMapEnd(); } @@ -13339,9 +13565,9 @@ break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast554; - xfer += iprot->readI32(ecast554); - this->eventType = (PartitionEventType::type)ecast554; + int32_t ecast561; + xfer += iprot->readI32(ecast561); + this->eventType = (PartitionEventType::type)ecast561; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -13374,11 +13600,11 @@ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter555; - for (_iter555 = this->part_vals.begin(); _iter555 != this->part_vals.end(); ++_iter555) + std::map ::const_iterator _iter562; + for (_iter562 = this->part_vals.begin(); _iter562 != this->part_vals.end(); ++_iter562) { - xfer += oprot->writeString(_iter555->first); - xfer += oprot->writeString(_iter555->second); + xfer += oprot->writeString(_iter562->first); + xfer += oprot->writeString(_iter562->second); } xfer += oprot->writeMapEnd(); } @@ -13408,11 +13634,11 @@ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter556; - for (_iter556 = (*(this->part_vals)).begin(); _iter556 != (*(this->part_vals)).end(); ++_iter556) + std::map ::const_iterator _iter563; + for (_iter563 = (*(this->part_vals)).begin(); _iter563 != (*(this->part_vals)).end(); ++_iter563) { - xfer += oprot->writeString(_iter556->first); - xfer += oprot->writeString(_iter556->second); + xfer += oprot->writeString(_iter563->first); + xfer += oprot->writeString(_iter563->second); } xfer += oprot->writeMapEnd(); } @@ -14717,14 +14943,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size557; - ::apache::thrift::protocol::TType _etype560; - xfer += iprot->readListBegin(_etype560, _size557); - this->success.resize(_size557); - uint32_t _i561; - for (_i561 = 0; _i561 < _size557; ++_i561) + uint32_t _size564; + ::apache::thrift::protocol::TType _etype567; + xfer += iprot->readListBegin(_etype567, _size564); + this->success.resize(_size564); + uint32_t _i568; + for (_i568 = 0; _i568 < _size564; ++_i568) { - xfer += this->success[_i561].read(iprot); + xfer += this->success[_i568].read(iprot); } xfer += iprot->readListEnd(); } @@ -14771,10 +14997,10 @@ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter562; - for (_iter562 = this->success.begin(); _iter562 != this->success.end(); ++_iter562) + std::vector ::const_iterator _iter569; + for (_iter569 = this->success.begin(); _iter569 != this->success.end(); ++_iter569) { - xfer += (*_iter562).write(oprot); + xfer += (*_iter569).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14817,14 +15043,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size563; - ::apache::thrift::protocol::TType _etype566; - xfer += iprot->readListBegin(_etype566, _size563); - (*(this->success)).resize(_size563); - uint32_t _i567; - for (_i567 = 0; _i567 < _size563; ++_i567) + uint32_t _size570; + ::apache::thrift::protocol::TType _etype573; + xfer += iprot->readListBegin(_etype573, _size570); + (*(this->success)).resize(_size570); + uint32_t _i574; + for (_i574 = 0; _i574 < _size570; ++_i574) { - xfer += (*(this->success))[_i567].read(iprot); + xfer += (*(this->success))[_i574].read(iprot); } xfer += iprot->readListEnd(); } @@ -14983,14 +15209,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size568; - ::apache::thrift::protocol::TType _etype571; - xfer += iprot->readListBegin(_etype571, _size568); - this->success.resize(_size568); - uint32_t _i572; - for (_i572 = 0; _i572 < _size568; ++_i572) + uint32_t _size575; + ::apache::thrift::protocol::TType _etype578; + xfer += iprot->readListBegin(_etype578, _size575); + this->success.resize(_size575); + uint32_t _i579; + for (_i579 = 0; _i579 < _size575; ++_i579) { - xfer += iprot->readString(this->success[_i572]); + xfer += iprot->readString(this->success[_i579]); } xfer += iprot->readListEnd(); } @@ -15029,10 +15255,10 @@ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter573; - for (_iter573 = this->success.begin(); _iter573 != this->success.end(); ++_iter573) + std::vector ::const_iterator _iter580; + for (_iter580 = this->success.begin(); _iter580 != this->success.end(); ++_iter580) { - xfer += oprot->writeString((*_iter573)); + xfer += oprot->writeString((*_iter580)); } xfer += oprot->writeListEnd(); } @@ -15071,14 +15297,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size574; - ::apache::thrift::protocol::TType _etype577; - xfer += iprot->readListBegin(_etype577, _size574); - (*(this->success)).resize(_size574); - uint32_t _i578; - for (_i578 = 0; _i578 < _size574; ++_i578) + uint32_t _size581; + ::apache::thrift::protocol::TType _etype584; + xfer += iprot->readListBegin(_etype584, _size581); + (*(this->success)).resize(_size581); + uint32_t _i585; + for (_i585 = 0; _i585 < _size581; ++_i585) { - xfer += iprot->readString((*(this->success))[_i578]); + xfer += iprot->readString((*(this->success))[_i585]); } xfer += iprot->readListEnd(); } @@ -17152,14 +17378,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size579; - ::apache::thrift::protocol::TType _etype582; - xfer += iprot->readListBegin(_etype582, _size579); - this->success.resize(_size579); - uint32_t _i583; - for (_i583 = 0; _i583 < _size579; ++_i583) + uint32_t _size586; + ::apache::thrift::protocol::TType _etype589; + xfer += iprot->readListBegin(_etype589, _size586); + this->success.resize(_size586); + uint32_t _i590; + for (_i590 = 0; _i590 < _size586; ++_i590) { - xfer += iprot->readString(this->success[_i583]); + xfer += iprot->readString(this->success[_i590]); } xfer += iprot->readListEnd(); } @@ -17198,10 +17424,10 @@ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter584; - for (_iter584 = this->success.begin(); _iter584 != this->success.end(); ++_iter584) + std::vector ::const_iterator _iter591; + for (_iter591 = this->success.begin(); _iter591 != this->success.end(); ++_iter591) { - xfer += oprot->writeString((*_iter584)); + xfer += oprot->writeString((*_iter591)); } xfer += oprot->writeListEnd(); } @@ -17240,14 +17466,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size585; - ::apache::thrift::protocol::TType _etype588; - xfer += iprot->readListBegin(_etype588, _size585); - (*(this->success)).resize(_size585); - uint32_t _i589; - for (_i589 = 0; _i589 < _size585; ++_i589) + uint32_t _size592; + ::apache::thrift::protocol::TType _etype595; + xfer += iprot->readListBegin(_etype595, _size592); + (*(this->success)).resize(_size592); + uint32_t _i596; + for (_i596 = 0; _i596 < _size592; ++_i596) { - xfer += iprot->readString((*(this->success))[_i589]); + xfer += iprot->readString((*(this->success))[_i596]); } xfer += iprot->readListEnd(); } @@ -17314,9 +17540,9 @@ break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast590; - xfer += iprot->readI32(ecast590); - this->principal_type = (PrincipalType::type)ecast590; + int32_t ecast597; + xfer += iprot->readI32(ecast597); + this->principal_type = (PrincipalType::type)ecast597; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -17332,9 +17558,9 @@ break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast591; - xfer += iprot->readI32(ecast591); - this->grantorType = (PrincipalType::type)ecast591; + int32_t ecast598; + xfer += iprot->readI32(ecast598); + this->grantorType = (PrincipalType::type)ecast598; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -17580,9 +17806,9 @@ break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast592; - xfer += iprot->readI32(ecast592); - this->principal_type = (PrincipalType::type)ecast592; + int32_t ecast599; + xfer += iprot->readI32(ecast599); + this->principal_type = (PrincipalType::type)ecast599; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -17788,9 +18014,9 @@ break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast593; - xfer += iprot->readI32(ecast593); - this->principal_type = (PrincipalType::type)ecast593; + int32_t ecast600; + xfer += iprot->readI32(ecast600); + this->principal_type = (PrincipalType::type)ecast600; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -17866,14 +18092,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size594; - ::apache::thrift::protocol::TType _etype597; - xfer += iprot->readListBegin(_etype597, _size594); - this->success.resize(_size594); - uint32_t _i598; - for (_i598 = 0; _i598 < _size594; ++_i598) + uint32_t _size601; + ::apache::thrift::protocol::TType _etype604; + xfer += iprot->readListBegin(_etype604, _size601); + this->success.resize(_size601); + uint32_t _i605; + for (_i605 = 0; _i605 < _size601; ++_i605) { - xfer += this->success[_i598].read(iprot); + xfer += this->success[_i605].read(iprot); } xfer += iprot->readListEnd(); } @@ -17912,10 +18138,10 @@ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter599; - for (_iter599 = this->success.begin(); _iter599 != this->success.end(); ++_iter599) + std::vector ::const_iterator _iter606; + for (_iter606 = this->success.begin(); _iter606 != this->success.end(); ++_iter606) { - xfer += (*_iter599).write(oprot); + xfer += (*_iter606).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17954,14 +18180,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size600; - ::apache::thrift::protocol::TType _etype603; - xfer += iprot->readListBegin(_etype603, _size600); - (*(this->success)).resize(_size600); - uint32_t _i604; - for (_i604 = 0; _i604 < _size600; ++_i604) + uint32_t _size607; + ::apache::thrift::protocol::TType _etype610; + xfer += iprot->readListBegin(_etype610, _size607); + (*(this->success)).resize(_size607); + uint32_t _i611; + for (_i611 = 0; _i611 < _size607; ++_i611) { - xfer += (*(this->success))[_i604].read(iprot); + xfer += (*(this->success))[_i611].read(iprot); } xfer += iprot->readListEnd(); } @@ -18030,14 +18256,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size605; - ::apache::thrift::protocol::TType _etype608; - xfer += iprot->readListBegin(_etype608, _size605); - this->group_names.resize(_size605); - uint32_t _i609; - for (_i609 = 0; _i609 < _size605; ++_i609) + uint32_t _size612; + ::apache::thrift::protocol::TType _etype615; + xfer += iprot->readListBegin(_etype615, _size612); + this->group_names.resize(_size612); + uint32_t _i616; + for (_i616 = 0; _i616 < _size612; ++_i616) { - xfer += iprot->readString(this->group_names[_i609]); + xfer += iprot->readString(this->group_names[_i616]); } xfer += iprot->readListEnd(); } @@ -18073,10 +18299,10 @@ xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter610; - for (_iter610 = this->group_names.begin(); _iter610 != this->group_names.end(); ++_iter610) + std::vector ::const_iterator _iter617; + for (_iter617 = this->group_names.begin(); _iter617 != this->group_names.end(); ++_iter617) { - xfer += oprot->writeString((*_iter610)); + xfer += oprot->writeString((*_iter617)); } xfer += oprot->writeListEnd(); } @@ -18102,10 +18328,10 @@ xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter611; - for (_iter611 = (*(this->group_names)).begin(); _iter611 != (*(this->group_names)).end(); ++_iter611) + std::vector ::const_iterator _iter618; + for (_iter618 = (*(this->group_names)).begin(); _iter618 != (*(this->group_names)).end(); ++_iter618) { - xfer += oprot->writeString((*_iter611)); + xfer += oprot->writeString((*_iter618)); } xfer += oprot->writeListEnd(); } @@ -18262,9 +18488,9 @@ break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast612; - xfer += iprot->readI32(ecast612); - this->principal_type = (PrincipalType::type)ecast612; + int32_t ecast619; + xfer += iprot->readI32(ecast619); + this->principal_type = (PrincipalType::type)ecast619; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -18356,14 +18582,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size613; - ::apache::thrift::protocol::TType _etype616; - xfer += iprot->readListBegin(_etype616, _size613); - this->success.resize(_size613); - uint32_t _i617; - for (_i617 = 0; _i617 < _size613; ++_i617) + uint32_t _size620; + ::apache::thrift::protocol::TType _etype623; + xfer += iprot->readListBegin(_etype623, _size620); + this->success.resize(_size620); + uint32_t _i624; + for (_i624 = 0; _i624 < _size620; ++_i624) { - xfer += this->success[_i617].read(iprot); + xfer += this->success[_i624].read(iprot); } xfer += iprot->readListEnd(); } @@ -18402,10 +18628,10 @@ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter618; - for (_iter618 = this->success.begin(); _iter618 != this->success.end(); ++_iter618) + std::vector ::const_iterator _iter625; + for (_iter625 = this->success.begin(); _iter625 != this->success.end(); ++_iter625) { - xfer += (*_iter618).write(oprot); + xfer += (*_iter625).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18444,14 +18670,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size619; - ::apache::thrift::protocol::TType _etype622; - xfer += iprot->readListBegin(_etype622, _size619); - (*(this->success)).resize(_size619); - uint32_t _i623; - for (_i623 = 0; _i623 < _size619; ++_i623) + uint32_t _size626; + ::apache::thrift::protocol::TType _etype629; + xfer += iprot->readListBegin(_etype629, _size626); + (*(this->success)).resize(_size626); + uint32_t _i630; + for (_i630 = 0; _i630 < _size626; ++_i630) { - xfer += (*(this->success))[_i623].read(iprot); + xfer += (*(this->success))[_i630].read(iprot); } xfer += iprot->readListEnd(); } @@ -18876,14 +19102,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size624; - ::apache::thrift::protocol::TType _etype627; - xfer += iprot->readListBegin(_etype627, _size624); - this->group_names.resize(_size624); - uint32_t _i628; - for (_i628 = 0; _i628 < _size624; ++_i628) + uint32_t _size631; + ::apache::thrift::protocol::TType _etype634; + xfer += iprot->readListBegin(_etype634, _size631); + this->group_names.resize(_size631); + uint32_t _i635; + for (_i635 = 0; _i635 < _size631; ++_i635) { - xfer += iprot->readString(this->group_names[_i628]); + xfer += iprot->readString(this->group_names[_i635]); } xfer += iprot->readListEnd(); } @@ -18915,10 +19141,10 @@ xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter629; - for (_iter629 = this->group_names.begin(); _iter629 != this->group_names.end(); ++_iter629) + std::vector ::const_iterator _iter636; + for (_iter636 = this->group_names.begin(); _iter636 != this->group_names.end(); ++_iter636) { - xfer += oprot->writeString((*_iter629)); + xfer += oprot->writeString((*_iter636)); } xfer += oprot->writeListEnd(); } @@ -18940,10 +19166,10 @@ xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter630; - for (_iter630 = (*(this->group_names)).begin(); _iter630 != (*(this->group_names)).end(); ++_iter630) + std::vector ::const_iterator _iter637; + for (_iter637 = (*(this->group_names)).begin(); _iter637 != (*(this->group_names)).end(); ++_iter637) { - xfer += oprot->writeString((*_iter630)); + xfer += oprot->writeString((*_iter637)); } xfer += oprot->writeListEnd(); } @@ -18978,14 +19204,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size631; - ::apache::thrift::protocol::TType _etype634; - xfer += iprot->readListBegin(_etype634, _size631); - this->success.resize(_size631); - uint32_t _i635; - for (_i635 = 0; _i635 < _size631; ++_i635) + uint32_t _size638; + ::apache::thrift::protocol::TType _etype641; + xfer += iprot->readListBegin(_etype641, _size638); + this->success.resize(_size638); + uint32_t _i642; + for (_i642 = 0; _i642 < _size638; ++_i642) { - xfer += iprot->readString(this->success[_i635]); + xfer += iprot->readString(this->success[_i642]); } xfer += iprot->readListEnd(); } @@ -19024,10 +19250,10 @@ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter636; - for (_iter636 = this->success.begin(); _iter636 != this->success.end(); ++_iter636) + std::vector ::const_iterator _iter643; + for (_iter643 = this->success.begin(); _iter643 != this->success.end(); ++_iter643) { - xfer += oprot->writeString((*_iter636)); + xfer += oprot->writeString((*_iter643)); } xfer += oprot->writeListEnd(); } @@ -19066,14 +19292,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size637; - ::apache::thrift::protocol::TType _etype640; - xfer += iprot->readListBegin(_etype640, _size637); - (*(this->success)).resize(_size637); - uint32_t _i641; - for (_i641 = 0; _i641 < _size637; ++_i641) + uint32_t _size644; + ::apache::thrift::protocol::TType _etype647; + xfer += iprot->readListBegin(_etype647, _size644); + (*(this->success)).resize(_size644); + uint32_t _i648; + for (_i648 = 0; _i648 < _size644; ++_i648) { - xfer += iprot->readString((*(this->success))[_i641]); + xfer += iprot->readString((*(this->success))[_i648]); } xfer += iprot->readListEnd(); } @@ -22838,6 +23064,68 @@ return; } +bool ThriftHiveMetastoreClient::partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) +{ + send_partition_name_has_valid_characters(part_vals, throw_exception); + return recv_partition_name_has_valid_characters(); +} + +void ThriftHiveMetastoreClient::send_partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("partition_name_has_valid_characters", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_partition_name_has_valid_characters_pargs args; + args.part_vals = &part_vals; + args.throw_exception = &throw_exception; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_partition_name_has_valid_characters() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("partition_name_has_valid_characters") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_partition_name_has_valid_characters_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "partition_name_has_valid_characters failed: unknown result"); +} + void ThriftHiveMetastoreClient::get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) { send_get_config_value(name, defaultValue); @@ -27832,6 +28120,63 @@ } } +void ThriftHiveMetastoreProcessor::process_partition_name_has_valid_characters(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.partition_name_has_valid_characters", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.partition_name_has_valid_characters"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters"); + } + + ThriftHiveMetastore_partition_name_has_valid_characters_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters", bytes); + } + + ThriftHiveMetastore_partition_name_has_valid_characters_result result; + try { + result.success = iface_->partition_name_has_valid_characters(args.part_vals, args.throw_exception); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = o1; + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("partition_name_has_valid_characters", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters"); + } + + oprot->writeMessageBegin("partition_name_has_valid_characters", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.partition_name_has_valid_characters", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_get_config_value(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = NULL; Index: metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h =================================================================== --- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (revision 1448321) +++ metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (working copy) @@ -65,6 +65,7 @@ virtual void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts) = 0; virtual void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) = 0; virtual void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part) = 0; + virtual bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) = 0; virtual void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) = 0; virtual void partition_name_to_vals(std::vector & _return, const std::string& part_name) = 0; virtual void partition_name_to_spec(std::map & _return, const std::string& part_name) = 0; @@ -279,6 +280,10 @@ void rename_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const Partition& /* new_part */) { return; } + bool partition_name_has_valid_characters(const std::vector & /* part_vals */, const bool /* throw_exception */) { + bool _return = false; + return _return; + } void get_config_value(std::string& /* _return */, const std::string& /* name */, const std::string& /* defaultValue */) { return; } @@ -7427,6 +7432,133 @@ }; +typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset { + _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset() : part_vals(false), throw_exception(false) {} + bool part_vals; + bool throw_exception; +} _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset; + +class ThriftHiveMetastore_partition_name_has_valid_characters_args { + public: + + ThriftHiveMetastore_partition_name_has_valid_characters_args() : throw_exception(0) { + } + + virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_args() throw() {} + + std::vector part_vals; + bool throw_exception; + + _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset __isset; + + void __set_part_vals(const std::vector & val) { + part_vals = val; + } + + void __set_throw_exception(const bool val) { + throw_exception = val; + } + + bool operator == (const ThriftHiveMetastore_partition_name_has_valid_characters_args & rhs) const + { + if (!(part_vals == rhs.part_vals)) + return false; + if (!(throw_exception == rhs.throw_exception)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_partition_name_has_valid_characters_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_partition_name_has_valid_characters_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_partition_name_has_valid_characters_pargs { + public: + + + virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_pargs() throw() {} + + const std::vector * part_vals; + const bool* throw_exception; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset { + _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset() : success(false), o1(false) {} + bool success; + bool o1; +} _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset; + +class ThriftHiveMetastore_partition_name_has_valid_characters_result { + public: + + ThriftHiveMetastore_partition_name_has_valid_characters_result() : success(0) { + } + + virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_result() throw() {} + + bool success; + MetaException o1; + + _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset __isset; + + void __set_success(const bool val) { + success = val; + } + + void __set_o1(const MetaException& val) { + o1 = val; + } + + bool operator == (const ThriftHiveMetastore_partition_name_has_valid_characters_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_partition_name_has_valid_characters_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_partition_name_has_valid_characters_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset { + _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset() : success(false), o1(false) {} + bool success; + bool o1; +} _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset; + +class ThriftHiveMetastore_partition_name_has_valid_characters_presult { + public: + + + virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_presult() throw() {} + + bool* success; + MetaException o1; + + _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_get_config_value_args__isset { _ThriftHiveMetastore_get_config_value_args__isset() : name(false), defaultValue(false) {} bool name; @@ -11936,6 +12068,9 @@ void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part); void send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part); void recv_rename_partition(); + bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception); + void send_partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception); + bool recv_partition_name_has_valid_characters(); void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue); void send_get_config_value(const std::string& name, const std::string& defaultValue); void recv_get_config_value(std::string& _return); @@ -12088,6 +12223,7 @@ void process_alter_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_alter_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_rename_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_partition_name_has_valid_characters(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_config_value(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_partition_name_to_vals(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_partition_name_to_spec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -12172,6 +12308,7 @@ processMap_["alter_partitions"] = &ThriftHiveMetastoreProcessor::process_alter_partitions; processMap_["alter_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_partition_with_environment_context; processMap_["rename_partition"] = &ThriftHiveMetastoreProcessor::process_rename_partition; + processMap_["partition_name_has_valid_characters"] = &ThriftHiveMetastoreProcessor::process_partition_name_has_valid_characters; processMap_["get_config_value"] = &ThriftHiveMetastoreProcessor::process_get_config_value; processMap_["partition_name_to_vals"] = &ThriftHiveMetastoreProcessor::process_partition_name_to_vals; processMap_["partition_name_to_spec"] = &ThriftHiveMetastoreProcessor::process_partition_name_to_spec; @@ -12706,6 +12843,15 @@ ifaces_[i]->rename_partition(db_name, tbl_name, part_vals, new_part); } + bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->partition_name_has_valid_characters(part_vals, throw_exception); + } + return ifaces_[i]->partition_name_has_valid_characters(part_vals, throw_exception); + } + void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) { size_t sz = ifaces_.size(); size_t i = 0; Index: metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp =================================================================== --- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (revision 1448321) +++ metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (working copy) @@ -267,6 +267,11 @@ printf("rename_partition\n"); } + bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception) { + // Your implementation goes here + printf("partition_name_has_valid_characters\n"); + } + void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) { // Your implementation goes here printf("get_config_value\n"); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Database.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Database.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Database.java (working copy) @@ -708,7 +708,7 @@ for (int _i79 = 0; _i79 < _map78.size; ++_i79) { String _key80; // required - String _val81; // required + String _val81; // optional _key80 = iprot.readString(); _val81 = iprot.readString(); struct.parameters.put(_key80, _val81); @@ -858,7 +858,7 @@ for (int _i85 = 0; _i85 < _map84.size; ++_i85) { String _key86; // required - String _val87; // required + String _val87; // optional _key86 = iprot.readString(); _val87 = iprot.readString(); struct.parameters.put(_key86, _val87); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/EnvironmentContext.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/EnvironmentContext.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/EnvironmentContext.java (working copy) @@ -356,7 +356,7 @@ for (int _i247 = 0; _i247 < _map246.size; ++_i247) { String _key248; // required - String _val249; // required + String _val249; // optional _key248 = iprot.readString(); _val249 = iprot.readString(); struct.properties.put(_key248, _val249); @@ -439,7 +439,7 @@ for (int _i253 = 0; _i253 < _map252.size; ++_i253) { String _key254; // required - String _val255; // required + String _val255; // optional _key254 = iprot.readString(); _val255 = iprot.readString(); struct.properties.put(_key254, _val255); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Index.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Index.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Index.java (working copy) @@ -1145,7 +1145,7 @@ for (int _i211 = 0; _i211 < _map210.size; ++_i211) { String _key212; // required - String _val213; // required + String _val213; // optional _key212 = iprot.readString(); _val213 = iprot.readString(); struct.parameters.put(_key212, _val213); @@ -1362,7 +1362,7 @@ for (int _i217 = 0; _i217 < _map216.size; ++_i217) { String _key218; // required - String _val219; // required + String _val219; // optional _key218 = iprot.readString(); _val219 = iprot.readString(); struct.parameters.put(_key218, _val219); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Partition.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Partition.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Partition.java (working copy) @@ -1005,7 +1005,7 @@ for (int _i196 = 0; _i196 < _map195.size; ++_i196) { String _key197; // required - String _val198; // required + String _val198; // optional _key197 = iprot.readString(); _val198 = iprot.readString(); struct.parameters.put(_key197, _val198); @@ -1219,7 +1219,7 @@ for (int _i207 = 0; _i207 < _map206.size; ++_i207) { String _key208; // required - String _val209; // required + String _val209; // optional _key208 = iprot.readString(); _val209 = iprot.readString(); struct.parameters.put(_key208, _val209); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PrincipalPrivilegeSet.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PrincipalPrivilegeSet.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PrincipalPrivilegeSet.java (working copy) @@ -580,7 +580,7 @@ for (int _i25 = 0; _i25 < _map24.size; ++_i25) { String _key26; // required - List _val27; // required + List _val27; // optional _key26 = iprot.readString(); { org.apache.thrift.protocol.TList _list28 = iprot.readListBegin(); @@ -611,7 +611,7 @@ for (int _i32 = 0; _i32 < _map31.size; ++_i32) { String _key33; // required - List _val34; // required + List _val34; // optional _key33 = iprot.readString(); { org.apache.thrift.protocol.TList _list35 = iprot.readListBegin(); @@ -642,7 +642,7 @@ for (int _i39 = 0; _i39 < _map38.size; ++_i39) { String _key40; // required - List _val41; // required + List _val41; // optional _key40 = iprot.readString(); { org.apache.thrift.protocol.TList _list42 = iprot.readListBegin(); @@ -827,7 +827,7 @@ for (int _i58 = 0; _i58 < _map57.size; ++_i58) { String _key59; // required - List _val60; // required + List _val60; // optional _key59 = iprot.readString(); { org.apache.thrift.protocol.TList _list61 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); @@ -852,7 +852,7 @@ for (int _i65 = 0; _i65 < _map64.size; ++_i65) { String _key66; // required - List _val67; // required + List _val67; // optional _key66 = iprot.readString(); { org.apache.thrift.protocol.TList _list68 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); @@ -877,7 +877,7 @@ for (int _i72 = 0; _i72 < _map71.size; ++_i72) { String _key73; // required - List _val74; // required + List _val74; // optional _key73 = iprot.readString(); { org.apache.thrift.protocol.TList _list75 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Schema.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Schema.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Schema.java (working copy) @@ -476,7 +476,7 @@ for (int _i232 = 0; _i232 < _map231.size; ++_i232) { String _key233; // required - String _val234; // required + String _val234; // optional _key233 = iprot.readString(); _val234 = iprot.readString(); struct.properties.put(_key233, _val234); @@ -597,7 +597,7 @@ for (int _i243 = 0; _i243 < _map242.size; ++_i243) { String _key244; // required - String _val245; // required + String _val245; // optional _key244 = iprot.readString(); _val245 = iprot.readString(); struct.properties.put(_key244, _val245); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SerDeInfo.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SerDeInfo.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SerDeInfo.java (working copy) @@ -534,7 +534,7 @@ for (int _i89 = 0; _i89 < _map88.size; ++_i89) { String _key90; // required - String _val91; // required + String _val91; // optional _key90 = iprot.readString(); _val91 = iprot.readString(); struct.parameters.put(_key90, _val91); @@ -647,7 +647,7 @@ for (int _i95 = 0; _i95 < _map94.size; ++_i95) { String _key96; // required - String _val97; // required + String _val97; // optional _key96 = iprot.readString(); _val97 = iprot.readString(); struct.parameters.put(_key96, _val97); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SkewedInfo.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SkewedInfo.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SkewedInfo.java (working copy) @@ -613,7 +613,7 @@ for (int _i108 = 0; _i108 < _map107.size; ++_i108) { List _key109; // required - String _val110; // required + String _val110; // optional { org.apache.thrift.protocol.TList _list111 = iprot.readListBegin(); _key109 = new ArrayList(_list111.size); @@ -815,7 +815,7 @@ for (int _i134 = 0; _i134 < _map133.size; ++_i134) { List _key135; // required - String _val136; // required + String _val136; // optional { org.apache.thrift.protocol.TList _list137 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); _key135 = new ArrayList(_list137.size); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/StorageDescriptor.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/StorageDescriptor.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/StorageDescriptor.java (working copy) @@ -1410,7 +1410,7 @@ for (int _i150 = 0; _i150 < _map149.size; ++_i150) { String _key151; // required - String _val152; // required + String _val152; // optional _key151 = iprot.readString(); _val152 = iprot.readString(); struct.parameters.put(_key151, _val152); @@ -1734,7 +1734,7 @@ for (int _i171 = 0; _i171 < _map170.size; ++_i171) { String _key172; // required - String _val173; // required + String _val173; // optional _key172 = iprot.readString(); _val173 = iprot.readString(); struct.parameters.put(_key172, _val173); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Table.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Table.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Table.java (working copy) @@ -1423,7 +1423,7 @@ for (int _i178 = 0; _i178 < _map177.size; ++_i178) { String _key179; // required - String _val180; // required + String _val180; // optional _key179 = iprot.readString(); _val180 = iprot.readString(); struct.parameters.put(_key179, _val180); @@ -1723,7 +1723,7 @@ for (int _i189 = 0; _i189 < _map188.size; ++_i189) { String _key190; // required - String _val191; // required + String _val191; // optional _key190 = iprot.readString(); _val191 = iprot.readString(); struct.parameters.put(_key190, _val191); Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java (revision 1448321) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java (working copy) @@ -136,6 +136,8 @@ public void rename_partition(String db_name, String tbl_name, List part_vals, Partition new_part) throws InvalidOperationException, MetaException, org.apache.thrift.TException; + public boolean partition_name_has_valid_characters(List part_vals, boolean throw_exception) throws MetaException, org.apache.thrift.TException; + public String get_config_value(String name, String defaultValue) throws ConfigValSecurityException, org.apache.thrift.TException; public List partition_name_to_vals(String part_name) throws MetaException, org.apache.thrift.TException; @@ -300,6 +302,8 @@ public void rename_partition(String db_name, String tbl_name, List part_vals, Partition new_part, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void partition_name_has_valid_characters(List part_vals, boolean throw_exception, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get_config_value(String name, String defaultValue, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void partition_name_to_vals(String part_name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -1889,6 +1893,33 @@ return; } + public boolean partition_name_has_valid_characters(List part_vals, boolean throw_exception) throws MetaException, org.apache.thrift.TException + { + send_partition_name_has_valid_characters(part_vals, throw_exception); + return recv_partition_name_has_valid_characters(); + } + + public void send_partition_name_has_valid_characters(List part_vals, boolean throw_exception) throws org.apache.thrift.TException + { + partition_name_has_valid_characters_args args = new partition_name_has_valid_characters_args(); + args.setPart_vals(part_vals); + args.setThrow_exception(throw_exception); + sendBase("partition_name_has_valid_characters", args); + } + + public boolean recv_partition_name_has_valid_characters() throws MetaException, org.apache.thrift.TException + { + partition_name_has_valid_characters_result result = new partition_name_has_valid_characters_result(); + receiveBase(result, "partition_name_has_valid_characters"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.o1 != null) { + throw result.o1; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "partition_name_has_valid_characters failed: unknown result"); + } + public String get_config_value(String name, String defaultValue) throws ConfigValSecurityException, org.apache.thrift.TException { send_get_config_value(name, defaultValue); @@ -4678,6 +4709,41 @@ } } + public void partition_name_has_valid_characters(List part_vals, boolean throw_exception, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + partition_name_has_valid_characters_call method_call = new partition_name_has_valid_characters_call(part_vals, throw_exception, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class partition_name_has_valid_characters_call extends org.apache.thrift.async.TAsyncMethodCall { + private List part_vals; + private boolean throw_exception; + public partition_name_has_valid_characters_call(List part_vals, boolean throw_exception, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.part_vals = part_vals; + this.throw_exception = throw_exception; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("partition_name_has_valid_characters", org.apache.thrift.protocol.TMessageType.CALL, 0)); + partition_name_has_valid_characters_args args = new partition_name_has_valid_characters_args(); + args.setPart_vals(part_vals); + args.setThrow_exception(throw_exception); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws MetaException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_partition_name_has_valid_characters(); + } + } + public void get_config_value(String name, String defaultValue, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); get_config_value_call method_call = new get_config_value_call(name, defaultValue, resultHandler, this, ___protocolFactory, ___transport); @@ -5861,6 +5927,7 @@ processMap.put("alter_partitions", new alter_partitions()); processMap.put("alter_partition_with_environment_context", new alter_partition_with_environment_context()); processMap.put("rename_partition", new rename_partition()); + processMap.put("partition_name_has_valid_characters", new partition_name_has_valid_characters()); processMap.put("get_config_value", new get_config_value()); processMap.put("partition_name_to_vals", new partition_name_to_vals()); processMap.put("partition_name_to_spec", new partition_name_to_spec()); @@ -7200,6 +7267,31 @@ } } + public static class partition_name_has_valid_characters extends org.apache.thrift.ProcessFunction { + public partition_name_has_valid_characters() { + super("partition_name_has_valid_characters"); + } + + public partition_name_has_valid_characters_args getEmptyArgsInstance() { + return new partition_name_has_valid_characters_args(); + } + + protected boolean isOneway() { + return false; + } + + public partition_name_has_valid_characters_result getResult(I iface, partition_name_has_valid_characters_args args) throws org.apache.thrift.TException { + partition_name_has_valid_characters_result result = new partition_name_has_valid_characters_result(); + try { + result.success = iface.partition_name_has_valid_characters(args.part_vals, args.throw_exception); + result.setSuccessIsSet(true); + } catch (MetaException o1) { + result.o1 = o1; + } + return result; + } + } + public static class get_config_value extends org.apache.thrift.ProcessFunction { public get_config_value() { super("get_config_value"); @@ -17258,7 +17350,7 @@ for (int _i273 = 0; _i273 < _map272.size; ++_i273) { String _key274; // required - Type _val275; // required + Type _val275; // optional _key274 = iprot.readString(); _val275 = new Type(); _val275.read(iprot); @@ -17362,7 +17454,7 @@ for (int _i279 = 0; _i279 < _map278.size; ++_i279) { String _key280; // required - Type _val281; // required + Type _val281; // optional _key280 = iprot.readString(); _val281 = new Type(); _val281.read(iprot); @@ -64407,6 +64499,982 @@ } + public static class partition_name_has_valid_characters_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("partition_name_has_valid_characters_args"); + + private static final org.apache.thrift.protocol.TField PART_VALS_FIELD_DESC = new org.apache.thrift.protocol.TField("part_vals", org.apache.thrift.protocol.TType.LIST, (short)1); + private static final org.apache.thrift.protocol.TField THROW_EXCEPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("throw_exception", org.apache.thrift.protocol.TType.BOOL, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new partition_name_has_valid_characters_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new partition_name_has_valid_characters_argsTupleSchemeFactory()); + } + + private List part_vals; // required + private boolean throw_exception; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PART_VALS((short)1, "part_vals"), + THROW_EXCEPTION((short)2, "throw_exception"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // PART_VALS + return PART_VALS; + case 2: // THROW_EXCEPTION + return THROW_EXCEPTION; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __THROW_EXCEPTION_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PART_VALS, new org.apache.thrift.meta_data.FieldMetaData("part_vals", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + tmpMap.put(_Fields.THROW_EXCEPTION, new org.apache.thrift.meta_data.FieldMetaData("throw_exception", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(partition_name_has_valid_characters_args.class, metaDataMap); + } + + public partition_name_has_valid_characters_args() { + } + + public partition_name_has_valid_characters_args( + List part_vals, + boolean throw_exception) + { + this(); + this.part_vals = part_vals; + this.throw_exception = throw_exception; + setThrow_exceptionIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public partition_name_has_valid_characters_args(partition_name_has_valid_characters_args other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetPart_vals()) { + List __this__part_vals = new ArrayList(); + for (String other_element : other.part_vals) { + __this__part_vals.add(other_element); + } + this.part_vals = __this__part_vals; + } + this.throw_exception = other.throw_exception; + } + + public partition_name_has_valid_characters_args deepCopy() { + return new partition_name_has_valid_characters_args(this); + } + + @Override + public void clear() { + this.part_vals = null; + setThrow_exceptionIsSet(false); + this.throw_exception = false; + } + + public int getPart_valsSize() { + return (this.part_vals == null) ? 0 : this.part_vals.size(); + } + + public java.util.Iterator getPart_valsIterator() { + return (this.part_vals == null) ? null : this.part_vals.iterator(); + } + + public void addToPart_vals(String elem) { + if (this.part_vals == null) { + this.part_vals = new ArrayList(); + } + this.part_vals.add(elem); + } + + public List getPart_vals() { + return this.part_vals; + } + + public void setPart_vals(List part_vals) { + this.part_vals = part_vals; + } + + public void unsetPart_vals() { + this.part_vals = null; + } + + /** Returns true if field part_vals is set (has been assigned a value) and false otherwise */ + public boolean isSetPart_vals() { + return this.part_vals != null; + } + + public void setPart_valsIsSet(boolean value) { + if (!value) { + this.part_vals = null; + } + } + + public boolean isThrow_exception() { + return this.throw_exception; + } + + public void setThrow_exception(boolean throw_exception) { + this.throw_exception = throw_exception; + setThrow_exceptionIsSet(true); + } + + public void unsetThrow_exception() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __THROW_EXCEPTION_ISSET_ID); + } + + /** Returns true if field throw_exception is set (has been assigned a value) and false otherwise */ + public boolean isSetThrow_exception() { + return EncodingUtils.testBit(__isset_bitfield, __THROW_EXCEPTION_ISSET_ID); + } + + public void setThrow_exceptionIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __THROW_EXCEPTION_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PART_VALS: + if (value == null) { + unsetPart_vals(); + } else { + setPart_vals((List)value); + } + break; + + case THROW_EXCEPTION: + if (value == null) { + unsetThrow_exception(); + } else { + setThrow_exception((Boolean)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PART_VALS: + return getPart_vals(); + + case THROW_EXCEPTION: + return Boolean.valueOf(isThrow_exception()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case PART_VALS: + return isSetPart_vals(); + case THROW_EXCEPTION: + return isSetThrow_exception(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof partition_name_has_valid_characters_args) + return this.equals((partition_name_has_valid_characters_args)that); + return false; + } + + public boolean equals(partition_name_has_valid_characters_args that) { + if (that == null) + return false; + + boolean this_present_part_vals = true && this.isSetPart_vals(); + boolean that_present_part_vals = true && that.isSetPart_vals(); + if (this_present_part_vals || that_present_part_vals) { + if (!(this_present_part_vals && that_present_part_vals)) + return false; + if (!this.part_vals.equals(that.part_vals)) + return false; + } + + boolean this_present_throw_exception = true; + boolean that_present_throw_exception = true; + if (this_present_throw_exception || that_present_throw_exception) { + if (!(this_present_throw_exception && that_present_throw_exception)) + return false; + if (this.throw_exception != that.throw_exception) + return false; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_part_vals = true && (isSetPart_vals()); + builder.append(present_part_vals); + if (present_part_vals) + builder.append(part_vals); + + boolean present_throw_exception = true; + builder.append(present_throw_exception); + if (present_throw_exception) + builder.append(throw_exception); + + return builder.toHashCode(); + } + + public int compareTo(partition_name_has_valid_characters_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + partition_name_has_valid_characters_args typedOther = (partition_name_has_valid_characters_args)other; + + lastComparison = Boolean.valueOf(isSetPart_vals()).compareTo(typedOther.isSetPart_vals()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPart_vals()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.part_vals, typedOther.part_vals); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetThrow_exception()).compareTo(typedOther.isSetThrow_exception()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetThrow_exception()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.throw_exception, typedOther.throw_exception); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("partition_name_has_valid_characters_args("); + boolean first = true; + + sb.append("part_vals:"); + if (this.part_vals == null) { + sb.append("null"); + } else { + sb.append(this.part_vals); + } + first = false; + if (!first) sb.append(", "); + sb.append("throw_exception:"); + sb.append(this.throw_exception); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class partition_name_has_valid_characters_argsStandardSchemeFactory implements SchemeFactory { + public partition_name_has_valid_characters_argsStandardScheme getScheme() { + return new partition_name_has_valid_characters_argsStandardScheme(); + } + } + + private static class partition_name_has_valid_characters_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_has_valid_characters_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // PART_VALS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list530 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list530.size); + for (int _i531 = 0; _i531 < _list530.size; ++_i531) + { + String _elem532; // required + _elem532 = iprot.readString(); + struct.part_vals.add(_elem532); + } + iprot.readListEnd(); + } + struct.setPart_valsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // THROW_EXCEPTION + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.throw_exception = iprot.readBool(); + struct.setThrow_exceptionIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_has_valid_characters_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.part_vals != null) { + oprot.writeFieldBegin(PART_VALS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); + for (String _iter533 : struct.part_vals) + { + oprot.writeString(_iter533); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(THROW_EXCEPTION_FIELD_DESC); + oprot.writeBool(struct.throw_exception); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class partition_name_has_valid_characters_argsTupleSchemeFactory implements SchemeFactory { + public partition_name_has_valid_characters_argsTupleScheme getScheme() { + return new partition_name_has_valid_characters_argsTupleScheme(); + } + } + + private static class partition_name_has_valid_characters_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_has_valid_characters_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPart_vals()) { + optionals.set(0); + } + if (struct.isSetThrow_exception()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPart_vals()) { + { + oprot.writeI32(struct.part_vals.size()); + for (String _iter534 : struct.part_vals) + { + oprot.writeString(_iter534); + } + } + } + if (struct.isSetThrow_exception()) { + oprot.writeBool(struct.throw_exception); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_has_valid_characters_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list535 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list535.size); + for (int _i536 = 0; _i536 < _list535.size; ++_i536) + { + String _elem537; // required + _elem537 = iprot.readString(); + struct.part_vals.add(_elem537); + } + } + struct.setPart_valsIsSet(true); + } + if (incoming.get(1)) { + struct.throw_exception = iprot.readBool(); + struct.setThrow_exceptionIsSet(true); + } + } + } + + } + + public static class partition_name_has_valid_characters_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("partition_name_has_valid_characters_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new partition_name_has_valid_characters_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new partition_name_has_valid_characters_resultTupleSchemeFactory()); + } + + private boolean success; // required + private MetaException o1; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + O1((short)1, "o1"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(partition_name_has_valid_characters_result.class, metaDataMap); + } + + public partition_name_has_valid_characters_result() { + } + + public partition_name_has_valid_characters_result( + boolean success, + MetaException o1) + { + this(); + this.success = success; + setSuccessIsSet(true); + this.o1 = o1; + } + + /** + * Performs a deep copy on other. + */ + public partition_name_has_valid_characters_result(partition_name_has_valid_characters_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + if (other.isSetO1()) { + this.o1 = new MetaException(other.o1); + } + } + + public partition_name_has_valid_characters_result deepCopy() { + return new partition_name_has_valid_characters_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + this.o1 = null; + } + + public boolean isSuccess() { + return this.success; + } + + public void setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + } + + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public MetaException getO1() { + return this.o1; + } + + public void setO1(MetaException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return Boolean.valueOf(isSuccess()); + + case O1: + return getO1(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case O1: + return isSetO1(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof partition_name_has_valid_characters_result) + return this.equals((partition_name_has_valid_characters_result)that); + return false; + } + + public boolean equals(partition_name_has_valid_characters_result that) { + if (that == null) + return false; + + boolean this_present_success = true; + boolean that_present_success = true; + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (this.success != that.success) + return false; + } + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_success = true; + builder.append(present_success); + if (present_success) + builder.append(success); + + boolean present_o1 = true && (isSetO1()); + builder.append(present_o1); + if (present_o1) + builder.append(o1); + + return builder.toHashCode(); + } + + public int compareTo(partition_name_has_valid_characters_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + partition_name_has_valid_characters_result typedOther = (partition_name_has_valid_characters_result)other; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(typedOther.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, typedOther.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("partition_name_has_valid_characters_result("); + boolean first = true; + + sb.append("success:"); + sb.append(this.success); + first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class partition_name_has_valid_characters_resultStandardSchemeFactory implements SchemeFactory { + public partition_name_has_valid_characters_resultStandardScheme getScheme() { + return new partition_name_has_valid_characters_resultStandardScheme(); + } + } + + private static class partition_name_has_valid_characters_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_has_valid_characters_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_has_valid_characters_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeBool(struct.success); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class partition_name_has_valid_characters_resultTupleSchemeFactory implements SchemeFactory { + public partition_name_has_valid_characters_resultTupleScheme getScheme() { + return new partition_name_has_valid_characters_resultTupleScheme(); + } + } + + private static class partition_name_has_valid_characters_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_has_valid_characters_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetO1()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_has_valid_characters_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + } + } + + } + public static class get_config_value_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_config_value_args"); @@ -66087,13 +67155,13 @@ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list530 = iprot.readListBegin(); - struct.success = new ArrayList(_list530.size); - for (int _i531 = 0; _i531 < _list530.size; ++_i531) + org.apache.thrift.protocol.TList _list538 = iprot.readListBegin(); + struct.success = new ArrayList(_list538.size); + for (int _i539 = 0; _i539 < _list538.size; ++_i539) { - String _elem532; // required - _elem532 = iprot.readString(); - struct.success.add(_elem532); + String _elem540; // required + _elem540 = iprot.readString(); + struct.success.add(_elem540); } iprot.readListEnd(); } @@ -66128,9 +67196,9 @@ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter533 : struct.success) + for (String _iter541 : struct.success) { - oprot.writeString(_iter533); + oprot.writeString(_iter541); } oprot.writeListEnd(); } @@ -66169,9 +67237,9 @@ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter534 : struct.success) + for (String _iter542 : struct.success) { - oprot.writeString(_iter534); + oprot.writeString(_iter542); } } } @@ -66186,13 +67254,13 @@ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list535 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list535.size); - for (int _i536 = 0; _i536 < _list535.size; ++_i536) + org.apache.thrift.protocol.TList _list543 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list543.size); + for (int _i544 = 0; _i544 < _list543.size; ++_i544) { - String _elem537; // required - _elem537 = iprot.readString(); - struct.success.add(_elem537); + String _elem545; // required + _elem545 = iprot.readString(); + struct.success.add(_elem545); } } struct.setSuccessIsSet(true); @@ -66966,15 +68034,15 @@ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map538 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map538.size); - for (int _i539 = 0; _i539 < _map538.size; ++_i539) + org.apache.thrift.protocol.TMap _map546 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map546.size); + for (int _i547 = 0; _i547 < _map546.size; ++_i547) { - String _key540; // required - String _val541; // required - _key540 = iprot.readString(); - _val541 = iprot.readString(); - struct.success.put(_key540, _val541); + String _key548; // required + String _val549; // optional + _key548 = iprot.readString(); + _val549 = iprot.readString(); + struct.success.put(_key548, _val549); } iprot.readMapEnd(); } @@ -67009,10 +68077,10 @@ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (Map.Entry _iter542 : struct.success.entrySet()) + for (Map.Entry _iter550 : struct.success.entrySet()) { - oprot.writeString(_iter542.getKey()); - oprot.writeString(_iter542.getValue()); + oprot.writeString(_iter550.getKey()); + oprot.writeString(_iter550.getValue()); } oprot.writeMapEnd(); } @@ -67051,10 +68119,10 @@ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter543 : struct.success.entrySet()) + for (Map.Entry _iter551 : struct.success.entrySet()) { - oprot.writeString(_iter543.getKey()); - oprot.writeString(_iter543.getValue()); + oprot.writeString(_iter551.getKey()); + oprot.writeString(_iter551.getValue()); } } } @@ -67069,15 +68137,15 @@ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map544 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new HashMap(2*_map544.size); - for (int _i545 = 0; _i545 < _map544.size; ++_i545) + org.apache.thrift.protocol.TMap _map552 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new HashMap(2*_map552.size); + for (int _i553 = 0; _i553 < _map552.size; ++_i553) { - String _key546; // required - String _val547; // required - _key546 = iprot.readString(); - _val547 = iprot.readString(); - struct.success.put(_key546, _val547); + String _key554; // required + String _val555; // optional + _key554 = iprot.readString(); + _val555 = iprot.readString(); + struct.success.put(_key554, _val555); } } struct.setSuccessIsSet(true); @@ -67683,15 +68751,15 @@ case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map548 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map548.size); - for (int _i549 = 0; _i549 < _map548.size; ++_i549) + org.apache.thrift.protocol.TMap _map556 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map556.size); + for (int _i557 = 0; _i557 < _map556.size; ++_i557) { - String _key550; // required - String _val551; // required - _key550 = iprot.readString(); - _val551 = iprot.readString(); - struct.part_vals.put(_key550, _val551); + String _key558; // required + String _val559; // optional + _key558 = iprot.readString(); + _val559 = iprot.readString(); + struct.part_vals.put(_key558, _val559); } iprot.readMapEnd(); } @@ -67735,10 +68803,10 @@ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter552 : struct.part_vals.entrySet()) + for (Map.Entry _iter560 : struct.part_vals.entrySet()) { - oprot.writeString(_iter552.getKey()); - oprot.writeString(_iter552.getValue()); + oprot.writeString(_iter560.getKey()); + oprot.writeString(_iter560.getValue()); } oprot.writeMapEnd(); } @@ -67789,10 +68857,10 @@ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter553 : struct.part_vals.entrySet()) + for (Map.Entry _iter561 : struct.part_vals.entrySet()) { - oprot.writeString(_iter553.getKey()); - oprot.writeString(_iter553.getValue()); + oprot.writeString(_iter561.getKey()); + oprot.writeString(_iter561.getValue()); } } } @@ -67815,15 +68883,15 @@ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map554 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map554.size); - for (int _i555 = 0; _i555 < _map554.size; ++_i555) + org.apache.thrift.protocol.TMap _map562 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map562.size); + for (int _i563 = 0; _i563 < _map562.size; ++_i563) { - String _key556; // required - String _val557; // required - _key556 = iprot.readString(); - _val557 = iprot.readString(); - struct.part_vals.put(_key556, _val557); + String _key564; // required + String _val565; // optional + _key564 = iprot.readString(); + _val565 = iprot.readString(); + struct.part_vals.put(_key564, _val565); } } struct.setPart_valsIsSet(true); @@ -69318,15 +70386,15 @@ case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map558 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map558.size); - for (int _i559 = 0; _i559 < _map558.size; ++_i559) + org.apache.thrift.protocol.TMap _map566 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map566.size); + for (int _i567 = 0; _i567 < _map566.size; ++_i567) { - String _key560; // required - String _val561; // required - _key560 = iprot.readString(); - _val561 = iprot.readString(); - struct.part_vals.put(_key560, _val561); + String _key568; // required + String _val569; // optional + _key568 = iprot.readString(); + _val569 = iprot.readString(); + struct.part_vals.put(_key568, _val569); } iprot.readMapEnd(); } @@ -69370,10 +70438,10 @@ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter562 : struct.part_vals.entrySet()) + for (Map.Entry _iter570 : struct.part_vals.entrySet()) { - oprot.writeString(_iter562.getKey()); - oprot.writeString(_iter562.getValue()); + oprot.writeString(_iter570.getKey()); + oprot.writeString(_iter570.getValue()); } oprot.writeMapEnd(); } @@ -69424,10 +70492,10 @@ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter563 : struct.part_vals.entrySet()) + for (Map.Entry _iter571 : struct.part_vals.entrySet()) { - oprot.writeString(_iter563.getKey()); - oprot.writeString(_iter563.getValue()); + oprot.writeString(_iter571.getKey()); + oprot.writeString(_iter571.getValue()); } } } @@ -69450,15 +70518,15 @@ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map564 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map564.size); - for (int _i565 = 0; _i565 < _map564.size; ++_i565) + org.apache.thrift.protocol.TMap _map572 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map572.size); + for (int _i573 = 0; _i573 < _map572.size; ++_i573) { - String _key566; // required - String _val567; // required - _key566 = iprot.readString(); - _val567 = iprot.readString(); - struct.part_vals.put(_key566, _val567); + String _key574; // required + String _val575; // optional + _key574 = iprot.readString(); + _val575 = iprot.readString(); + struct.part_vals.put(_key574, _val575); } } struct.setPart_valsIsSet(true); @@ -76182,14 +77250,14 @@ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list568 = iprot.readListBegin(); - struct.success = new ArrayList(_list568.size); - for (int _i569 = 0; _i569 < _list568.size; ++_i569) + org.apache.thrift.protocol.TList _list576 = iprot.readListBegin(); + struct.success = new ArrayList(_list576.size); + for (int _i577 = 0; _i577 < _list576.size; ++_i577) { - Index _elem570; // required - _elem570 = new Index(); - _elem570.read(iprot); - struct.success.add(_elem570); + Index _elem578; // required + _elem578 = new Index(); + _elem578.read(iprot); + struct.success.add(_elem578); } iprot.readListEnd(); } @@ -76233,9 +77301,9 @@ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Index _iter571 : struct.success) + for (Index _iter579 : struct.success) { - _iter571.write(oprot); + _iter579.write(oprot); } oprot.writeListEnd(); } @@ -76282,9 +77350,9 @@ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Index _iter572 : struct.success) + for (Index _iter580 : struct.success) { - _iter572.write(oprot); + _iter580.write(oprot); } } } @@ -76302,14 +77370,14 @@ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list573 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list573.size); - for (int _i574 = 0; _i574 < _list573.size; ++_i574) + org.apache.thrift.protocol.TList _list581 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list581.size); + for (int _i582 = 0; _i582 < _list581.size; ++_i582) { - Index _elem575; // required - _elem575 = new Index(); - _elem575.read(iprot); - struct.success.add(_elem575); + Index _elem583; // required + _elem583 = new Index(); + _elem583.read(iprot); + struct.success.add(_elem583); } } struct.setSuccessIsSet(true); @@ -77291,13 +78359,13 @@ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list576 = iprot.readListBegin(); - struct.success = new ArrayList(_list576.size); - for (int _i577 = 0; _i577 < _list576.size; ++_i577) + org.apache.thrift.protocol.TList _list584 = iprot.readListBegin(); + struct.success = new ArrayList(_list584.size); + for (int _i585 = 0; _i585 < _list584.size; ++_i585) { - String _elem578; // required - _elem578 = iprot.readString(); - struct.success.add(_elem578); + String _elem586; // required + _elem586 = iprot.readString(); + struct.success.add(_elem586); } iprot.readListEnd(); } @@ -77332,9 +78400,9 @@ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter579 : struct.success) + for (String _iter587 : struct.success) { - oprot.writeString(_iter579); + oprot.writeString(_iter587); } oprot.writeListEnd(); } @@ -77373,9 +78441,9 @@ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter580 : struct.success) + for (String _iter588 : struct.success) { - oprot.writeString(_iter580); + oprot.writeString(_iter588); } } } @@ -77390,13 +78458,13 @@ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list581 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list581.size); - for (int _i582 = 0; _i582 < _list581.size; ++_i582) + org.apache.thrift.protocol.TList _list589 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list589.size); + for (int _i590 = 0; _i590 < _list589.size; ++_i590) { - String _elem583; // required - _elem583 = iprot.readString(); - struct.success.add(_elem583); + String _elem591; // required + _elem591 = iprot.readString(); + struct.success.add(_elem591); } } struct.setSuccessIsSet(true); @@ -87602,13 +88670,13 @@ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list584 = iprot.readListBegin(); - struct.success = new ArrayList(_list584.size); - for (int _i585 = 0; _i585 < _list584.size; ++_i585) + org.apache.thrift.protocol.TList _list592 = iprot.readListBegin(); + struct.success = new ArrayList(_list592.size); + for (int _i593 = 0; _i593 < _list592.size; ++_i593) { - String _elem586; // required - _elem586 = iprot.readString(); - struct.success.add(_elem586); + String _elem594; // required + _elem594 = iprot.readString(); + struct.success.add(_elem594); } iprot.readListEnd(); } @@ -87643,9 +88711,9 @@ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter587 : struct.success) + for (String _iter595 : struct.success) { - oprot.writeString(_iter587); + oprot.writeString(_iter595); } oprot.writeListEnd(); } @@ -87684,9 +88752,9 @@ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter588 : struct.success) + for (String _iter596 : struct.success) { - oprot.writeString(_iter588); + oprot.writeString(_iter596); } } } @@ -87701,13 +88769,13 @@ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list589 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list589.size); - for (int _i590 = 0; _i590 < _list589.size; ++_i590) + org.apache.thrift.protocol.TList _list597 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list597.size); + for (int _i598 = 0; _i598 < _list597.size; ++_i598) { - String _elem591; // required - _elem591 = iprot.readString(); - struct.success.add(_elem591); + String _elem599; // required + _elem599 = iprot.readString(); + struct.success.add(_elem599); } } struct.setSuccessIsSet(true); @@ -90998,14 +92066,14 @@ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list592 = iprot.readListBegin(); - struct.success = new ArrayList(_list592.size); - for (int _i593 = 0; _i593 < _list592.size; ++_i593) + org.apache.thrift.protocol.TList _list600 = iprot.readListBegin(); + struct.success = new ArrayList(_list600.size); + for (int _i601 = 0; _i601 < _list600.size; ++_i601) { - Role _elem594; // required - _elem594 = new Role(); - _elem594.read(iprot); - struct.success.add(_elem594); + Role _elem602; // required + _elem602 = new Role(); + _elem602.read(iprot); + struct.success.add(_elem602); } iprot.readListEnd(); } @@ -91040,9 +92108,9 @@ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Role _iter595 : struct.success) + for (Role _iter603 : struct.success) { - _iter595.write(oprot); + _iter603.write(oprot); } oprot.writeListEnd(); } @@ -91081,9 +92149,9 @@ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Role _iter596 : struct.success) + for (Role _iter604 : struct.success) { - _iter596.write(oprot); + _iter604.write(oprot); } } } @@ -91098,14 +92166,14 @@ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list597 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list597.size); - for (int _i598 = 0; _i598 < _list597.size; ++_i598) + org.apache.thrift.protocol.TList _list605 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list605.size); + for (int _i606 = 0; _i606 < _list605.size; ++_i606) { - Role _elem599; // required - _elem599 = new Role(); - _elem599.read(iprot); - struct.success.add(_elem599); + Role _elem607; // required + _elem607 = new Role(); + _elem607.read(iprot); + struct.success.add(_elem607); } } struct.setSuccessIsSet(true); @@ -91617,13 +92685,13 @@ case 3: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list600 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list600.size); - for (int _i601 = 0; _i601 < _list600.size; ++_i601) + org.apache.thrift.protocol.TList _list608 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list608.size); + for (int _i609 = 0; _i609 < _list608.size; ++_i609) { - String _elem602; // required - _elem602 = iprot.readString(); - struct.group_names.add(_elem602); + String _elem610; // required + _elem610 = iprot.readString(); + struct.group_names.add(_elem610); } iprot.readListEnd(); } @@ -91659,9 +92727,9 @@ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter603 : struct.group_names) + for (String _iter611 : struct.group_names) { - oprot.writeString(_iter603); + oprot.writeString(_iter611); } oprot.writeListEnd(); } @@ -91704,9 +92772,9 @@ if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter604 : struct.group_names) + for (String _iter612 : struct.group_names) { - oprot.writeString(_iter604); + oprot.writeString(_iter612); } } } @@ -91727,13 +92795,13 @@ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list605 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list605.size); - for (int _i606 = 0; _i606 < _list605.size; ++_i606) + org.apache.thrift.protocol.TList _list613 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list613.size); + for (int _i614 = 0; _i614 < _list613.size; ++_i614) { - String _elem607; // required - _elem607 = iprot.readString(); - struct.group_names.add(_elem607); + String _elem615; // required + _elem615 = iprot.readString(); + struct.group_names.add(_elem615); } } struct.setGroup_namesIsSet(true); @@ -93191,14 +94259,14 @@ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list608 = iprot.readListBegin(); - struct.success = new ArrayList(_list608.size); - for (int _i609 = 0; _i609 < _list608.size; ++_i609) + org.apache.thrift.protocol.TList _list616 = iprot.readListBegin(); + struct.success = new ArrayList(_list616.size); + for (int _i617 = 0; _i617 < _list616.size; ++_i617) { - HiveObjectPrivilege _elem610; // required - _elem610 = new HiveObjectPrivilege(); - _elem610.read(iprot); - struct.success.add(_elem610); + HiveObjectPrivilege _elem618; // required + _elem618 = new HiveObjectPrivilege(); + _elem618.read(iprot); + struct.success.add(_elem618); } iprot.readListEnd(); } @@ -93233,9 +94301,9 @@ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (HiveObjectPrivilege _iter611 : struct.success) + for (HiveObjectPrivilege _iter619 : struct.success) { - _iter611.write(oprot); + _iter619.write(oprot); } oprot.writeListEnd(); } @@ -93274,9 +94342,9 @@ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (HiveObjectPrivilege _iter612 : struct.success) + for (HiveObjectPrivilege _iter620 : struct.success) { - _iter612.write(oprot); + _iter620.write(oprot); } } } @@ -93291,14 +94359,14 @@ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list613 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list613.size); - for (int _i614 = 0; _i614 < _list613.size; ++_i614) + org.apache.thrift.protocol.TList _list621 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list621.size); + for (int _i622 = 0; _i622 < _list621.size; ++_i622) { - HiveObjectPrivilege _elem615; // required - _elem615 = new HiveObjectPrivilege(); - _elem615.read(iprot); - struct.success.add(_elem615); + HiveObjectPrivilege _elem623; // required + _elem623 = new HiveObjectPrivilege(); + _elem623.read(iprot); + struct.success.add(_elem623); } } struct.setSuccessIsSet(true); @@ -95371,13 +96439,13 @@ case 2: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list616 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list616.size); - for (int _i617 = 0; _i617 < _list616.size; ++_i617) + org.apache.thrift.protocol.TList _list624 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list624.size); + for (int _i625 = 0; _i625 < _list624.size; ++_i625) { - String _elem618; // required - _elem618 = iprot.readString(); - struct.group_names.add(_elem618); + String _elem626; // required + _elem626 = iprot.readString(); + struct.group_names.add(_elem626); } iprot.readListEnd(); } @@ -95408,9 +96476,9 @@ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter619 : struct.group_names) + for (String _iter627 : struct.group_names) { - oprot.writeString(_iter619); + oprot.writeString(_iter627); } oprot.writeListEnd(); } @@ -95447,9 +96515,9 @@ if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter620 : struct.group_names) + for (String _iter628 : struct.group_names) { - oprot.writeString(_iter620); + oprot.writeString(_iter628); } } } @@ -95465,13 +96533,13 @@ } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list621 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list621.size); - for (int _i622 = 0; _i622 < _list621.size; ++_i622) + org.apache.thrift.protocol.TList _list629 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list629.size); + for (int _i630 = 0; _i630 < _list629.size; ++_i630) { - String _elem623; // required - _elem623 = iprot.readString(); - struct.group_names.add(_elem623); + String _elem631; // required + _elem631 = iprot.readString(); + struct.group_names.add(_elem631); } } struct.setGroup_namesIsSet(true); @@ -95877,13 +96945,13 @@ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list624 = iprot.readListBegin(); - struct.success = new ArrayList(_list624.size); - for (int _i625 = 0; _i625 < _list624.size; ++_i625) + org.apache.thrift.protocol.TList _list632 = iprot.readListBegin(); + struct.success = new ArrayList(_list632.size); + for (int _i633 = 0; _i633 < _list632.size; ++_i633) { - String _elem626; // required - _elem626 = iprot.readString(); - struct.success.add(_elem626); + String _elem634; // required + _elem634 = iprot.readString(); + struct.success.add(_elem634); } iprot.readListEnd(); } @@ -95918,9 +96986,9 @@ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter627 : struct.success) + for (String _iter635 : struct.success) { - oprot.writeString(_iter627); + oprot.writeString(_iter635); } oprot.writeListEnd(); } @@ -95959,9 +97027,9 @@ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter628 : struct.success) + for (String _iter636 : struct.success) { - oprot.writeString(_iter628); + oprot.writeString(_iter636); } } } @@ -95976,13 +97044,13 @@ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list629 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list629.size); - for (int _i630 = 0; _i630 < _list629.size; ++_i630) + org.apache.thrift.protocol.TList _list637 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list637.size); + for (int _i638 = 0; _i638 < _list637.size; ++_i638) { - String _elem631; // required - _elem631 = iprot.readString(); - struct.success.add(_elem631); + String _elem639; // required + _elem639 = iprot.readString(); + struct.success.add(_elem639); } } struct.setSuccessIsSet(true); Index: metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php =================================================================== --- metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php (revision 1448321) +++ metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php (working copy) @@ -65,6 +65,7 @@ public function alter_partitions($db_name, $tbl_name, $new_parts); public function alter_partition_with_environment_context($db_name, $tbl_name, \metastore\Partition $new_part, \metastore\EnvironmentContext $environment_context); public function rename_partition($db_name, $tbl_name, $part_vals, \metastore\Partition $new_part); + public function partition_name_has_valid_characters($part_vals, $throw_exception); public function get_config_value($name, $defaultValue); public function partition_name_to_vals($part_name); public function partition_name_to_spec($part_name); @@ -2980,6 +2981,61 @@ return; } + public function partition_name_has_valid_characters($part_vals, $throw_exception) + { + $this->send_partition_name_has_valid_characters($part_vals, $throw_exception); + return $this->recv_partition_name_has_valid_characters(); + } + + public function send_partition_name_has_valid_characters($part_vals, $throw_exception) + { + $args = new \metastore\ThriftHiveMetastore_partition_name_has_valid_characters_args(); + $args->part_vals = $part_vals; + $args->throw_exception = $throw_exception; + $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'partition_name_has_valid_characters', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('partition_name_has_valid_characters', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_partition_name_has_valid_characters() + { + $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_partition_name_has_valid_characters_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; + + $this->input_->readMessageBegin($fname, $mtype, $rseqid); + if ($mtype == TMessageType::EXCEPTION) { + $x = new TApplicationException(); + $x->read($this->input_); + $this->input_->readMessageEnd(); + throw $x; + } + $result = new \metastore\ThriftHiveMetastore_partition_name_has_valid_characters_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + if ($result->o1 !== null) { + throw $result->o1; + } + throw new \Exception("partition_name_has_valid_characters failed: unknown result"); + } + public function get_config_value($name, $defaultValue) { $this->send_get_config_value($name, $defaultValue); @@ -16829,6 +16885,218 @@ } +class ThriftHiveMetastore_partition_name_has_valid_characters_args { + static $_TSPEC; + + public $part_vals = null; + public $throw_exception = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'part_vals', + 'type' => TType::LST, + 'etype' => TType::STRING, + 'elem' => array( + 'type' => TType::STRING, + ), + ), + 2 => array( + 'var' => 'throw_exception', + 'type' => TType::BOOL, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['part_vals'])) { + $this->part_vals = $vals['part_vals']; + } + if (isset($vals['throw_exception'])) { + $this->throw_exception = $vals['throw_exception']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_partition_name_has_valid_characters_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::LST) { + $this->part_vals = array(); + $_size467 = 0; + $_etype470 = 0; + $xfer += $input->readListBegin($_etype470, $_size467); + for ($_i471 = 0; $_i471 < $_size467; ++$_i471) + { + $elem472 = null; + $xfer += $input->readString($elem472); + $this->part_vals []= $elem472; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->throw_exception); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_partition_name_has_valid_characters_args'); + if ($this->part_vals !== null) { + if (!is_array($this->part_vals)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('part_vals', TType::LST, 1); + { + $output->writeListBegin(TType::STRING, count($this->part_vals)); + { + foreach ($this->part_vals as $iter473) + { + $xfer += $output->writeString($iter473); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->throw_exception !== null) { + $xfer += $output->writeFieldBegin('throw_exception', TType::BOOL, 2); + $xfer += $output->writeBool($this->throw_exception); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_partition_name_has_valid_characters_result { + static $_TSPEC; + + public $success = null; + public $o1 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::BOOL, + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_partition_name_has_valid_characters_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->success); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\MetaException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_partition_name_has_valid_characters_result'); + if ($this->success !== null) { + $xfer += $output->writeFieldBegin('success', TType::BOOL, 0); + $xfer += $output->writeBool($this->success); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class ThriftHiveMetastore_get_config_value_args { static $_TSPEC; @@ -17143,14 +17411,14 @@ case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size467 = 0; - $_etype470 = 0; - $xfer += $input->readListBegin($_etype470, $_size467); - for ($_i471 = 0; $_i471 < $_size467; ++$_i471) + $_size474 = 0; + $_etype477 = 0; + $xfer += $input->readListBegin($_etype477, $_size474); + for ($_i478 = 0; $_i478 < $_size474; ++$_i478) { - $elem472 = null; - $xfer += $input->readString($elem472); - $this->success []= $elem472; + $elem479 = null; + $xfer += $input->readString($elem479); + $this->success []= $elem479; } $xfer += $input->readListEnd(); } else { @@ -17186,9 +17454,9 @@ { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter473) + foreach ($this->success as $iter480) { - $xfer += $output->writeString($iter473); + $xfer += $output->writeString($iter480); } } $output->writeListEnd(); @@ -17339,17 +17607,17 @@ case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size474 = 0; - $_ktype475 = 0; - $_vtype476 = 0; - $xfer += $input->readMapBegin($_ktype475, $_vtype476, $_size474); - for ($_i478 = 0; $_i478 < $_size474; ++$_i478) + $_size481 = 0; + $_ktype482 = 0; + $_vtype483 = 0; + $xfer += $input->readMapBegin($_ktype482, $_vtype483, $_size481); + for ($_i485 = 0; $_i485 < $_size481; ++$_i485) { - $key479 = ''; - $val480 = ''; - $xfer += $input->readString($key479); - $xfer += $input->readString($val480); - $this->success[$key479] = $val480; + $key486 = ''; + $val487 = ''; + $xfer += $input->readString($key486); + $xfer += $input->readString($val487); + $this->success[$key486] = $val487; } $xfer += $input->readMapEnd(); } else { @@ -17385,10 +17653,10 @@ { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success)); { - foreach ($this->success as $kiter481 => $viter482) + foreach ($this->success as $kiter488 => $viter489) { - $xfer += $output->writeString($kiter481); - $xfer += $output->writeString($viter482); + $xfer += $output->writeString($kiter488); + $xfer += $output->writeString($viter489); } } $output->writeMapEnd(); @@ -17496,17 +17764,17 @@ case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size483 = 0; - $_ktype484 = 0; - $_vtype485 = 0; - $xfer += $input->readMapBegin($_ktype484, $_vtype485, $_size483); - for ($_i487 = 0; $_i487 < $_size483; ++$_i487) + $_size490 = 0; + $_ktype491 = 0; + $_vtype492 = 0; + $xfer += $input->readMapBegin($_ktype491, $_vtype492, $_size490); + for ($_i494 = 0; $_i494 < $_size490; ++$_i494) { - $key488 = ''; - $val489 = ''; - $xfer += $input->readString($key488); - $xfer += $input->readString($val489); - $this->part_vals[$key488] = $val489; + $key495 = ''; + $val496 = ''; + $xfer += $input->readString($key495); + $xfer += $input->readString($val496); + $this->part_vals[$key495] = $val496; } $xfer += $input->readMapEnd(); } else { @@ -17551,10 +17819,10 @@ { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter490 => $viter491) + foreach ($this->part_vals as $kiter497 => $viter498) { - $xfer += $output->writeString($kiter490); - $xfer += $output->writeString($viter491); + $xfer += $output->writeString($kiter497); + $xfer += $output->writeString($viter498); } } $output->writeMapEnd(); @@ -17846,17 +18114,17 @@ case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size492 = 0; - $_ktype493 = 0; - $_vtype494 = 0; - $xfer += $input->readMapBegin($_ktype493, $_vtype494, $_size492); - for ($_i496 = 0; $_i496 < $_size492; ++$_i496) + $_size499 = 0; + $_ktype500 = 0; + $_vtype501 = 0; + $xfer += $input->readMapBegin($_ktype500, $_vtype501, $_size499); + for ($_i503 = 0; $_i503 < $_size499; ++$_i503) { - $key497 = ''; - $val498 = ''; - $xfer += $input->readString($key497); - $xfer += $input->readString($val498); - $this->part_vals[$key497] = $val498; + $key504 = ''; + $val505 = ''; + $xfer += $input->readString($key504); + $xfer += $input->readString($val505); + $this->part_vals[$key504] = $val505; } $xfer += $input->readMapEnd(); } else { @@ -17901,10 +18169,10 @@ { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter499 => $viter500) + foreach ($this->part_vals as $kiter506 => $viter507) { - $xfer += $output->writeString($kiter499); - $xfer += $output->writeString($viter500); + $xfer += $output->writeString($kiter506); + $xfer += $output->writeString($viter507); } } $output->writeMapEnd(); @@ -19264,15 +19532,15 @@ case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size501 = 0; - $_etype504 = 0; - $xfer += $input->readListBegin($_etype504, $_size501); - for ($_i505 = 0; $_i505 < $_size501; ++$_i505) + $_size508 = 0; + $_etype511 = 0; + $xfer += $input->readListBegin($_etype511, $_size508); + for ($_i512 = 0; $_i512 < $_size508; ++$_i512) { - $elem506 = null; - $elem506 = new \metastore\Index(); - $xfer += $elem506->read($input); - $this->success []= $elem506; + $elem513 = null; + $elem513 = new \metastore\Index(); + $xfer += $elem513->read($input); + $this->success []= $elem513; } $xfer += $input->readListEnd(); } else { @@ -19316,9 +19584,9 @@ { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter507) + foreach ($this->success as $iter514) { - $xfer += $iter507->write($output); + $xfer += $iter514->write($output); } } $output->writeListEnd(); @@ -19510,14 +19778,14 @@ case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size508 = 0; - $_etype511 = 0; - $xfer += $input->readListBegin($_etype511, $_size508); - for ($_i512 = 0; $_i512 < $_size508; ++$_i512) + $_size515 = 0; + $_etype518 = 0; + $xfer += $input->readListBegin($_etype518, $_size515); + for ($_i519 = 0; $_i519 < $_size515; ++$_i519) { - $elem513 = null; - $xfer += $input->readString($elem513); - $this->success []= $elem513; + $elem520 = null; + $xfer += $input->readString($elem520); + $this->success []= $elem520; } $xfer += $input->readListEnd(); } else { @@ -19553,9 +19821,9 @@ { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter514) + foreach ($this->success as $iter521) { - $xfer += $output->writeString($iter514); + $xfer += $output->writeString($iter521); } } $output->writeListEnd(); @@ -21629,14 +21897,14 @@ case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size515 = 0; - $_etype518 = 0; - $xfer += $input->readListBegin($_etype518, $_size515); - for ($_i519 = 0; $_i519 < $_size515; ++$_i519) + $_size522 = 0; + $_etype525 = 0; + $xfer += $input->readListBegin($_etype525, $_size522); + for ($_i526 = 0; $_i526 < $_size522; ++$_i526) { - $elem520 = null; - $xfer += $input->readString($elem520); - $this->success []= $elem520; + $elem527 = null; + $xfer += $input->readString($elem527); + $this->success []= $elem527; } $xfer += $input->readListEnd(); } else { @@ -21672,9 +21940,9 @@ { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter521) + foreach ($this->success as $iter528) { - $xfer += $output->writeString($iter521); + $xfer += $output->writeString($iter528); } } $output->writeListEnd(); @@ -22314,15 +22582,15 @@ case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size522 = 0; - $_etype525 = 0; - $xfer += $input->readListBegin($_etype525, $_size522); - for ($_i526 = 0; $_i526 < $_size522; ++$_i526) + $_size529 = 0; + $_etype532 = 0; + $xfer += $input->readListBegin($_etype532, $_size529); + for ($_i533 = 0; $_i533 < $_size529; ++$_i533) { - $elem527 = null; - $elem527 = new \metastore\Role(); - $xfer += $elem527->read($input); - $this->success []= $elem527; + $elem534 = null; + $elem534 = new \metastore\Role(); + $xfer += $elem534->read($input); + $this->success []= $elem534; } $xfer += $input->readListEnd(); } else { @@ -22358,9 +22626,9 @@ { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter528) + foreach ($this->success as $iter535) { - $xfer += $iter528->write($output); + $xfer += $iter535->write($output); } } $output->writeListEnd(); @@ -22458,14 +22726,14 @@ case 3: if ($ftype == TType::LST) { $this->group_names = array(); - $_size529 = 0; - $_etype532 = 0; - $xfer += $input->readListBegin($_etype532, $_size529); - for ($_i533 = 0; $_i533 < $_size529; ++$_i533) + $_size536 = 0; + $_etype539 = 0; + $xfer += $input->readListBegin($_etype539, $_size536); + for ($_i540 = 0; $_i540 < $_size536; ++$_i540) { - $elem534 = null; - $xfer += $input->readString($elem534); - $this->group_names []= $elem534; + $elem541 = null; + $xfer += $input->readString($elem541); + $this->group_names []= $elem541; } $xfer += $input->readListEnd(); } else { @@ -22506,9 +22774,9 @@ { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter535) + foreach ($this->group_names as $iter542) { - $xfer += $output->writeString($iter535); + $xfer += $output->writeString($iter542); } } $output->writeListEnd(); @@ -22795,15 +23063,15 @@ case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size536 = 0; - $_etype539 = 0; - $xfer += $input->readListBegin($_etype539, $_size536); - for ($_i540 = 0; $_i540 < $_size536; ++$_i540) + $_size543 = 0; + $_etype546 = 0; + $xfer += $input->readListBegin($_etype546, $_size543); + for ($_i547 = 0; $_i547 < $_size543; ++$_i547) { - $elem541 = null; - $elem541 = new \metastore\HiveObjectPrivilege(); - $xfer += $elem541->read($input); - $this->success []= $elem541; + $elem548 = null; + $elem548 = new \metastore\HiveObjectPrivilege(); + $xfer += $elem548->read($input); + $this->success []= $elem548; } $xfer += $input->readListEnd(); } else { @@ -22839,9 +23107,9 @@ { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter542) + foreach ($this->success as $iter549) { - $xfer += $iter542->write($output); + $xfer += $iter549->write($output); } } $output->writeListEnd(); @@ -23264,14 +23532,14 @@ case 2: if ($ftype == TType::LST) { $this->group_names = array(); - $_size543 = 0; - $_etype546 = 0; - $xfer += $input->readListBegin($_etype546, $_size543); - for ($_i547 = 0; $_i547 < $_size543; ++$_i547) + $_size550 = 0; + $_etype553 = 0; + $xfer += $input->readListBegin($_etype553, $_size550); + for ($_i554 = 0; $_i554 < $_size550; ++$_i554) { - $elem548 = null; - $xfer += $input->readString($elem548); - $this->group_names []= $elem548; + $elem555 = null; + $xfer += $input->readString($elem555); + $this->group_names []= $elem555; } $xfer += $input->readListEnd(); } else { @@ -23304,9 +23572,9 @@ { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter549) + foreach ($this->group_names as $iter556) { - $xfer += $output->writeString($iter549); + $xfer += $output->writeString($iter556); } } $output->writeListEnd(); @@ -23376,14 +23644,14 @@ case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size550 = 0; - $_etype553 = 0; - $xfer += $input->readListBegin($_etype553, $_size550); - for ($_i554 = 0; $_i554 < $_size550; ++$_i554) + $_size557 = 0; + $_etype560 = 0; + $xfer += $input->readListBegin($_etype560, $_size557); + for ($_i561 = 0; $_i561 < $_size557; ++$_i561) { - $elem555 = null; - $xfer += $input->readString($elem555); - $this->success []= $elem555; + $elem562 = null; + $xfer += $input->readString($elem562); + $this->success []= $elem562; } $xfer += $input->readListEnd(); } else { @@ -23419,9 +23687,9 @@ { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter556) + foreach ($this->success as $iter563) { - $xfer += $output->writeString($iter556); + $xfer += $output->writeString($iter563); } } $output->writeListEnd(); Index: metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote =================================================================== --- metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote (revision 1448321) +++ metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote (working copy) @@ -72,6 +72,7 @@ print ' void alter_partitions(string db_name, string tbl_name, new_parts)' print ' void alter_partition_with_environment_context(string db_name, string tbl_name, Partition new_part, EnvironmentContext environment_context)' print ' void rename_partition(string db_name, string tbl_name, part_vals, Partition new_part)' + print ' bool partition_name_has_valid_characters( part_vals, bool throw_exception)' print ' string get_config_value(string name, string defaultValue)' print ' partition_name_to_vals(string part_name)' print ' partition_name_to_spec(string part_name)' @@ -448,6 +449,12 @@ sys.exit(1) pp.pprint(client.rename_partition(args[0],args[1],eval(args[2]),eval(args[3]),)) +elif cmd == 'partition_name_has_valid_characters': + if len(args) != 2: + print 'partition_name_has_valid_characters requires 2 args' + sys.exit(1) + pp.pprint(client.partition_name_has_valid_characters(eval(args[0]),eval(args[1]),)) + elif cmd == 'get_config_value': if len(args) != 2: print 'get_config_value requires 2 args' Index: metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py =================================================================== --- metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py (revision 1448321) +++ metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py (working copy) @@ -449,6 +449,14 @@ """ pass + def partition_name_has_valid_characters(self, part_vals, throw_exception): + """ + Parameters: + - part_vals + - throw_exception + """ + pass + def get_config_value(self, name, defaultValue): """ Parameters: @@ -2549,6 +2557,40 @@ raise result.o2 return + def partition_name_has_valid_characters(self, part_vals, throw_exception): + """ + Parameters: + - part_vals + - throw_exception + """ + self.send_partition_name_has_valid_characters(part_vals, throw_exception) + return self.recv_partition_name_has_valid_characters() + + def send_partition_name_has_valid_characters(self, part_vals, throw_exception): + self._oprot.writeMessageBegin('partition_name_has_valid_characters', TMessageType.CALL, self._seqid) + args = partition_name_has_valid_characters_args() + args.part_vals = part_vals + args.throw_exception = throw_exception + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_partition_name_has_valid_characters(self, ): + (fname, mtype, rseqid) = self._iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(self._iprot) + self._iprot.readMessageEnd() + raise x + result = partition_name_has_valid_characters_result() + result.read(self._iprot) + self._iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + raise TApplicationException(TApplicationException.MISSING_RESULT, "partition_name_has_valid_characters failed: unknown result"); + def get_config_value(self, name, defaultValue): """ Parameters: @@ -3739,6 +3781,7 @@ self._processMap["alter_partitions"] = Processor.process_alter_partitions self._processMap["alter_partition_with_environment_context"] = Processor.process_alter_partition_with_environment_context self._processMap["rename_partition"] = Processor.process_rename_partition + self._processMap["partition_name_has_valid_characters"] = Processor.process_partition_name_has_valid_characters self._processMap["get_config_value"] = Processor.process_get_config_value self._processMap["partition_name_to_vals"] = Processor.process_partition_name_to_vals self._processMap["partition_name_to_spec"] = Processor.process_partition_name_to_spec @@ -4594,6 +4637,20 @@ oprot.writeMessageEnd() oprot.trans.flush() + def process_partition_name_has_valid_characters(self, seqid, iprot, oprot): + args = partition_name_has_valid_characters_args() + args.read(iprot) + iprot.readMessageEnd() + result = partition_name_has_valid_characters_result() + try: + result.success = self._handler.partition_name_has_valid_characters(args.part_vals, args.throw_exception) + except MetaException as o1: + result.o1 = o1 + oprot.writeMessageBegin("partition_name_has_valid_characters", TMessageType.REPLY, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_get_config_value(self, seqid, iprot, oprot): args = get_config_value_args() args.read(iprot) @@ -13574,6 +13631,158 @@ def __ne__(self, other): return not (self == other) +class partition_name_has_valid_characters_args: + """ + Attributes: + - part_vals + - throw_exception + """ + + thrift_spec = ( + None, # 0 + (1, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 1 + (2, TType.BOOL, 'throw_exception', None, None, ), # 2 + ) + + def __init__(self, part_vals=None, throw_exception=None,): + self.part_vals = part_vals + self.throw_exception = throw_exception + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.LIST: + self.part_vals = [] + (_etype470, _size467) = iprot.readListBegin() + for _i471 in xrange(_size467): + _elem472 = iprot.readString(); + self.part_vals.append(_elem472) + iprot.readListEnd() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.BOOL: + self.throw_exception = iprot.readBool(); + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('partition_name_has_valid_characters_args') + if self.part_vals is not None: + oprot.writeFieldBegin('part_vals', TType.LIST, 1) + oprot.writeListBegin(TType.STRING, len(self.part_vals)) + for iter473 in self.part_vals: + oprot.writeString(iter473) + oprot.writeListEnd() + oprot.writeFieldEnd() + if self.throw_exception is not None: + oprot.writeFieldBegin('throw_exception', TType.BOOL, 2) + oprot.writeBool(self.throw_exception) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class partition_name_has_valid_characters_result: + """ + Attributes: + - success + - o1 + """ + + thrift_spec = ( + (0, TType.BOOL, 'success', None, None, ), # 0 + (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + ) + + def __init__(self, success=None, o1=None,): + self.success = success + self.o1 = o1 + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 0: + if ftype == TType.BOOL: + self.success = iprot.readBool(); + else: + iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = MetaException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('partition_name_has_valid_characters_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.BOOL, 0) + oprot.writeBool(self.success) + oprot.writeFieldEnd() + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class get_config_value_args: """ Attributes: @@ -13806,10 +14015,10 @@ if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype470, _size467) = iprot.readListBegin() - for _i471 in xrange(_size467): - _elem472 = iprot.readString(); - self.success.append(_elem472) + (_etype477, _size474) = iprot.readListBegin() + for _i478 in xrange(_size474): + _elem479 = iprot.readString(); + self.success.append(_elem479) iprot.readListEnd() else: iprot.skip(ftype) @@ -13832,8 +14041,8 @@ if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter473 in self.success: - oprot.writeString(iter473) + for iter480 in self.success: + oprot.writeString(iter480) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -13946,11 +14155,11 @@ if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype475, _vtype476, _size474 ) = iprot.readMapBegin() - for _i478 in xrange(_size474): - _key479 = iprot.readString(); - _val480 = iprot.readString(); - self.success[_key479] = _val480 + (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin() + for _i485 in xrange(_size481): + _key486 = iprot.readString(); + _val487 = iprot.readString(); + self.success[_key486] = _val487 iprot.readMapEnd() else: iprot.skip(ftype) @@ -13973,9 +14182,9 @@ if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success)) - for kiter481,viter482 in self.success.items(): - oprot.writeString(kiter481) - oprot.writeString(viter482) + for kiter488,viter489 in self.success.items(): + oprot.writeString(kiter488) + oprot.writeString(viter489) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14045,11 +14254,11 @@ elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype484, _vtype485, _size483 ) = iprot.readMapBegin() - for _i487 in xrange(_size483): - _key488 = iprot.readString(); - _val489 = iprot.readString(); - self.part_vals[_key488] = _val489 + (_ktype491, _vtype492, _size490 ) = iprot.readMapBegin() + for _i494 in xrange(_size490): + _key495 = iprot.readString(); + _val496 = iprot.readString(); + self.part_vals[_key495] = _val496 iprot.readMapEnd() else: iprot.skip(ftype) @@ -14079,9 +14288,9 @@ if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter490,viter491 in self.part_vals.items(): - oprot.writeString(kiter490) - oprot.writeString(viter491) + for kiter497,viter498 in self.part_vals.items(): + oprot.writeString(kiter497) + oprot.writeString(viter498) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -14277,11 +14486,11 @@ elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype493, _vtype494, _size492 ) = iprot.readMapBegin() - for _i496 in xrange(_size492): - _key497 = iprot.readString(); - _val498 = iprot.readString(); - self.part_vals[_key497] = _val498 + (_ktype500, _vtype501, _size499 ) = iprot.readMapBegin() + for _i503 in xrange(_size499): + _key504 = iprot.readString(); + _val505 = iprot.readString(); + self.part_vals[_key504] = _val505 iprot.readMapEnd() else: iprot.skip(ftype) @@ -14311,9 +14520,9 @@ if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter499,viter500 in self.part_vals.items(): - oprot.writeString(kiter499) - oprot.writeString(viter500) + for kiter506,viter507 in self.part_vals.items(): + oprot.writeString(kiter506) + oprot.writeString(viter507) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -15285,11 +15494,11 @@ if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype504, _size501) = iprot.readListBegin() - for _i505 in xrange(_size501): - _elem506 = Index() - _elem506.read(iprot) - self.success.append(_elem506) + (_etype511, _size508) = iprot.readListBegin() + for _i512 in xrange(_size508): + _elem513 = Index() + _elem513.read(iprot) + self.success.append(_elem513) iprot.readListEnd() else: iprot.skip(ftype) @@ -15318,8 +15527,8 @@ if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter507 in self.success: - iter507.write(oprot) + for iter514 in self.success: + iter514.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15460,10 +15669,10 @@ if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype511, _size508) = iprot.readListBegin() - for _i512 in xrange(_size508): - _elem513 = iprot.readString(); - self.success.append(_elem513) + (_etype518, _size515) = iprot.readListBegin() + for _i519 in xrange(_size515): + _elem520 = iprot.readString(); + self.success.append(_elem520) iprot.readListEnd() else: iprot.skip(ftype) @@ -15486,8 +15695,8 @@ if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter514 in self.success: - oprot.writeString(iter514) + for iter521 in self.success: + oprot.writeString(iter521) oprot.writeListEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -16997,10 +17206,10 @@ if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype518, _size515) = iprot.readListBegin() - for _i519 in xrange(_size515): - _elem520 = iprot.readString(); - self.success.append(_elem520) + (_etype525, _size522) = iprot.readListBegin() + for _i526 in xrange(_size522): + _elem527 = iprot.readString(); + self.success.append(_elem527) iprot.readListEnd() else: iprot.skip(ftype) @@ -17023,8 +17232,8 @@ if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter521 in self.success: - oprot.writeString(iter521) + for iter528 in self.success: + oprot.writeString(iter528) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17497,11 +17706,11 @@ if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype525, _size522) = iprot.readListBegin() - for _i526 in xrange(_size522): - _elem527 = Role() - _elem527.read(iprot) - self.success.append(_elem527) + (_etype532, _size529) = iprot.readListBegin() + for _i533 in xrange(_size529): + _elem534 = Role() + _elem534.read(iprot) + self.success.append(_elem534) iprot.readListEnd() else: iprot.skip(ftype) @@ -17524,8 +17733,8 @@ if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter528 in self.success: - iter528.write(oprot) + for iter535 in self.success: + iter535.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17593,10 +17802,10 @@ elif fid == 3: if ftype == TType.LIST: self.group_names = [] - (_etype532, _size529) = iprot.readListBegin() - for _i533 in xrange(_size529): - _elem534 = iprot.readString(); - self.group_names.append(_elem534) + (_etype539, _size536) = iprot.readListBegin() + for _i540 in xrange(_size536): + _elem541 = iprot.readString(); + self.group_names.append(_elem541) iprot.readListEnd() else: iprot.skip(ftype) @@ -17621,8 +17830,8 @@ if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter535 in self.group_names: - oprot.writeString(iter535) + for iter542 in self.group_names: + oprot.writeString(iter542) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17829,11 +18038,11 @@ if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype539, _size536) = iprot.readListBegin() - for _i540 in xrange(_size536): - _elem541 = HiveObjectPrivilege() - _elem541.read(iprot) - self.success.append(_elem541) + (_etype546, _size543) = iprot.readListBegin() + for _i547 in xrange(_size543): + _elem548 = HiveObjectPrivilege() + _elem548.read(iprot) + self.success.append(_elem548) iprot.readListEnd() else: iprot.skip(ftype) @@ -17856,8 +18065,8 @@ if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter542 in self.success: - iter542.write(oprot) + for iter549 in self.success: + iter549.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18182,10 +18391,10 @@ elif fid == 2: if ftype == TType.LIST: self.group_names = [] - (_etype546, _size543) = iprot.readListBegin() - for _i547 in xrange(_size543): - _elem548 = iprot.readString(); - self.group_names.append(_elem548) + (_etype553, _size550) = iprot.readListBegin() + for _i554 in xrange(_size550): + _elem555 = iprot.readString(); + self.group_names.append(_elem555) iprot.readListEnd() else: iprot.skip(ftype) @@ -18206,8 +18415,8 @@ if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter549 in self.group_names: - oprot.writeString(iter549) + for iter556 in self.group_names: + oprot.writeString(iter556) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18256,10 +18465,10 @@ if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype553, _size550) = iprot.readListBegin() - for _i554 in xrange(_size550): - _elem555 = iprot.readString(); - self.success.append(_elem555) + (_etype560, _size557) = iprot.readListBegin() + for _i561 in xrange(_size557): + _elem562 = iprot.readString(); + self.success.append(_elem562) iprot.readListEnd() else: iprot.skip(ftype) @@ -18282,8 +18491,8 @@ if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter556 in self.success: - oprot.writeString(iter556) + for iter563 in self.success: + oprot.writeString(iter563) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: Index: metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb =================================================================== --- metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb (revision 1448321) +++ metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb (working copy) @@ -844,6 +844,22 @@ return end + def partition_name_has_valid_characters(part_vals, throw_exception) + send_partition_name_has_valid_characters(part_vals, throw_exception) + return recv_partition_name_has_valid_characters() + end + + def send_partition_name_has_valid_characters(part_vals, throw_exception) + send_message('partition_name_has_valid_characters', Partition_name_has_valid_characters_args, :part_vals => part_vals, :throw_exception => throw_exception) + end + + def recv_partition_name_has_valid_characters() + result = receive_message(Partition_name_has_valid_characters_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'partition_name_has_valid_characters failed: unknown result') + end + def get_config_value(name, defaultValue) send_get_config_value(name, defaultValue) return recv_get_config_value() @@ -2037,6 +2053,17 @@ write_result(result, oprot, 'rename_partition', seqid) end + def process_partition_name_has_valid_characters(seqid, iprot, oprot) + args = read_args(iprot, Partition_name_has_valid_characters_args) + result = Partition_name_has_valid_characters_result.new() + begin + result.success = @handler.partition_name_has_valid_characters(args.part_vals, args.throw_exception) + rescue ::MetaException => o1 + result.o1 = o1 + end + write_result(result, oprot, 'partition_name_has_valid_characters', seqid) + end + def process_get_config_value(seqid, iprot, oprot) args = read_args(iprot, Get_config_value_args) result = Get_config_value_result.new() @@ -4387,6 +4414,42 @@ ::Thrift::Struct.generate_accessors self end + class Partition_name_has_valid_characters_args + include ::Thrift::Struct, ::Thrift::Struct_Union + PART_VALS = 1 + THROW_EXCEPTION = 2 + + FIELDS = { + PART_VALS => {:type => ::Thrift::Types::LIST, :name => 'part_vals', :element => {:type => ::Thrift::Types::STRING}}, + THROW_EXCEPTION => {:type => ::Thrift::Types::BOOL, :name => 'throw_exception'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Partition_name_has_valid_characters_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class Get_config_value_args include ::Thrift::Struct, ::Thrift::Struct_Union NAME = 1 Index: metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java =================================================================== --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java (revision 1448321) +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java (working copy) @@ -295,6 +295,7 @@ private List listeners; private List endFunctionListeners; private List initListeners; + private Pattern partitionValidationPattern; { classLoader = Thread.currentThread().getContextClassLoader(); @@ -344,6 +345,14 @@ MetaStoreEndFunctionListener.class, hiveConf, hiveConf.getVar(HiveConf.ConfVars.METASTORE_END_FUNCTION_LISTENERS)); + String partitionValidationRegex = + hiveConf.getVar(HiveConf.ConfVars.METASTORE_PARTITION_NAME_WHITELIST_PATTERN); + if (partitionValidationRegex != null && partitionValidationRegex != "") { + partitionValidationPattern = Pattern.compile(partitionValidationRegex); + } else { + partitionValidationPattern = null; + } + long cleanFreq = hiveConf.getLongVar(ConfVars.METASTORE_EVENT_CLEAN_FREQ) * 1000L; if (cleanFreq > 0) { // In default config, there is no timer. @@ -1485,6 +1494,8 @@ PreAddPartitionEvent event = new PreAddPartitionEvent(part, this); firePreEvent(event); + MetaStoreUtils.validatePartitionNameCharacters(part_vals, partitionValidationPattern); + tbl = ms.getTable(part.getDbName(), part.getTableName()); if (tbl == null) { throw new InvalidObjectException( @@ -1688,6 +1699,9 @@ try { firePreEvent(new PreAddPartitionEvent(part, this)); + MetaStoreUtils.validatePartitionNameCharacters(part.getValues(), + partitionValidationPattern); + Partition old_part = null; try { old_part = ms.getPartition(part.getDbName(), part @@ -2150,6 +2164,11 @@ try { firePreEvent(new PreAlterPartitionEvent(db_name, tbl_name, part_vals, new_part, this)); + if (part_vals != null && !part_vals.isEmpty()) { + MetaStoreUtils.validatePartitionNameCharacters(new_part.getValues(), + partitionValidationPattern); + } + oldPart = alterHandler.alterPartition(getMS(), wh, db_name, tbl_name, part_vals, new_part); for (MetaStoreEventListener listener : listeners) { @@ -4050,6 +4069,34 @@ Collections.addAll(groupNames, username); return groupNames; } + + @Override + public boolean partition_name_has_valid_characters(List part_vals, + boolean throw_exception) throws TException, MetaException { + startFunction("partition_name_has_valid_characters"); + boolean ret = false; + Exception ex = null; + try { + if (throw_exception) { + MetaStoreUtils.validatePartitionNameCharacters(part_vals, partitionValidationPattern); + ret = true; + } else { + ret = MetaStoreUtils.partitionNameHasValidCharacters(part_vals, + partitionValidationPattern); + } + } catch (Exception e) { + if (e instanceof MetaException) { + throw (MetaException)e; + } else { + ex = e; + MetaException me = new MetaException(); + me.initCause(e); + throw me; + } + } + endFunction("partition_name_has_valid_characters", true, null); + return ret; + } } public static IHMSHandler newHMSHandler(String name, HiveConf hiveConf) throws MetaException { Index: metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java =================================================================== --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java (revision 1448321) +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java (working copy) @@ -424,6 +424,11 @@ partName, envContext)); } + public void validatePartitionNameCharacters(List partVals) + throws TException, MetaException { + client.partition_name_has_valid_characters(partVals, true); + } + /** * Create a new Database * @param db Index: metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java =================================================================== --- metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java (revision 1448321) +++ metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java (working copy) @@ -491,6 +491,15 @@ UnknownTableException, UnknownDBException, UnknownPartitionException, InvalidPartitionException; /** + * @param partVals + * @throws TException + * @throws MetaException + */ + public void validatePartitionNameCharacters(List partVals) + throws TException, MetaException; + + + /** * @param tbl * @throws AlreadyExistsException * @throws InvalidObjectException Index: metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreUtils.java =================================================================== --- metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreUtils.java (revision 1448321) +++ metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreUtils.java (working copy) @@ -1140,4 +1140,37 @@ } } + public static void validatePartitionNameCharacters(List partVals, + Pattern partitionValidationPattern) throws MetaException { + + String invalidPartitionVal = + getPartitionValWithInvalidCharacter(partVals, partitionValidationPattern); + if (invalidPartitionVal != null) { + throw new MetaException("Partition value '" + invalidPartitionVal + + "' contains a character " + "not matched by whitelist pattern '" + + partitionValidationPattern.toString() + "'. " + "(configure with " + + HiveConf.ConfVars.METASTORE_PARTITION_NAME_WHITELIST_PATTERN.varname + ")"); + } + } + + public static boolean partitionNameHasValidCharacters(List partVals, + Pattern partitionValidationPattern) { + return getPartitionValWithInvalidCharacter(partVals, partitionValidationPattern) == null; + } + + private static String getPartitionValWithInvalidCharacter(List partVals, + Pattern partitionValidationPattern) { + if (partitionValidationPattern == null) { + return null; + } + + for (String partVal : partVals) { + if (!partitionValidationPattern.matcher(partVal).matches()) { + return partVal; + } + } + + return null; + } + } Index: metastore/src/java/org/apache/hadoop/hive/metastore/PartitionNameWhitelistPreEventListener.java =================================================================== --- metastore/src/java/org/apache/hadoop/hive/metastore/PartitionNameWhitelistPreEventListener.java (revision 1448321) +++ metastore/src/java/org/apache/hadoop/hive/metastore/PartitionNameWhitelistPreEventListener.java (working copy) @@ -1,70 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hadoop.hive.metastore; - -import java.util.List; -import java.util.regex.Pattern; - -import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hive.conf.HiveConf; -import org.apache.hadoop.hive.metastore.api.InvalidOperationException; -import org.apache.hadoop.hive.metastore.api.MetaException; -import org.apache.hadoop.hive.metastore.api.NoSuchObjectException; -import org.apache.hadoop.hive.metastore.events.PreAddPartitionEvent; -import org.apache.hadoop.hive.metastore.events.PreEventContext; - -public class PartitionNameWhitelistPreEventListener extends MetaStorePreEventListener { - - // When enabled, this hook causes an exception to be thrown - // if partition fields contain characters which are not - // matched by the whitelist - - private static String regex; - private static Pattern pattern; - - public PartitionNameWhitelistPreEventListener(Configuration config) { - super(config); - - regex = config.get(HiveConf.ConfVars.METASTORE_PARTITION_NAME_WHITELIST_PATTERN.varname); - pattern = Pattern.compile(regex); - } - - @Override - public void onEvent(PreEventContext event) throws MetaException, NoSuchObjectException, - InvalidOperationException { - - switch (event.getEventType()) { - case ADD_PARTITION: - checkWhitelist(((PreAddPartitionEvent) event).getPartition().getValues()); - break; - } - - } - - private static void checkWhitelist(List partVals) throws MetaException { - for (String partVal : partVals) { - if (!pattern.matcher(partVal).matches()) { - throw new MetaException("Partition value '" + partVal + "' contains a character " - + "not matched by whitelist pattern '" + regex + "'. " + "(configure with " - + HiveConf.ConfVars.METASTORE_PARTITION_NAME_WHITELIST_PATTERN.varname + ")"); - } - } - } - -} Index: metastore/src/test/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java =================================================================== --- metastore/src/test/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java (revision 1448321) +++ metastore/src/test/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java (working copy) @@ -2369,6 +2369,8 @@ } } + + /** * This method simulates another Hive metastore renaming a table, by accessing the db and * updating the name. Index: metastore/src/test/org/apache/hadoop/hive/metastore/TestPartitionNameWhitelistPreEventHook.java =================================================================== --- metastore/src/test/org/apache/hadoop/hive/metastore/TestPartitionNameWhitelistPreEventHook.java (revision 1448321) +++ metastore/src/test/org/apache/hadoop/hive/metastore/TestPartitionNameWhitelistPreEventHook.java (working copy) @@ -1,164 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hadoop.hive.metastore; - -import java.util.ArrayList; -import java.util.List; - -import junit.framework.Assert; - -import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hive.conf.HiveConf; -import org.apache.hadoop.hive.metastore.api.Partition; -import org.apache.hadoop.hive.metastore.events.PreAddPartitionEvent; -import org.apache.hadoop.hive.metastore.events.PreEventContext; -import org.junit.Test; - -// Validate CharacterWhitelistPreEventHook to ensure it refuses to process -// a partition add or append request if partition fields contain -// Unicode characters or commas - -public class TestPartitionNameWhitelistPreEventHook { - - // Runs an instance of DisallowUnicodePreEventListener - // Returns whether or not it succeeded - private boolean runHook(PreEventContext event) { - - Configuration config = new Configuration(); - - // match the printable ASCII characters except for commas - config.set(HiveConf.ConfVars.METASTORE_PARTITION_NAME_WHITELIST_PATTERN.varname - , "[\\x20-\\x7E&&[^,]]*"); - - PartitionNameWhitelistPreEventListener hook = - new PartitionNameWhitelistPreEventListener(config); - - try { - hook.onEvent(event); - } catch (Exception e) { - return false; - } - - return true; - } - - // Sample data - private List getPartValsWithUnicode() { - - List partVals = new ArrayList(); - partVals.add("klâwen"); - partVals.add("tägelîch"); - - return partVals; - - } - - private List getPartValsWithCommas() { - - List partVals = new ArrayList(); - partVals.add("a,b"); - partVals.add("c,d,e,f"); - - return partVals; - - } - - private List getPartValsWithValidCharacters() { - - List partVals = new ArrayList(); - partVals.add("part1"); - partVals.add("part2"); - - return partVals; - - } - - @Test - public void testAddPartitionWithCommas() { - - Partition partition = new Partition(); - partition.setValues(getPartValsWithCommas()); - - PreAddPartitionEvent event = new PreAddPartitionEvent(partition, null); - - Assert.assertFalse("Add a partition with commas in name", - runHook(event)); - } - - @Test - public void testAddPartitionWithUnicode() { - - Partition partition = new Partition(); - partition.setValues(getPartValsWithUnicode()); - - PreAddPartitionEvent event = new PreAddPartitionEvent(partition, null); - - Assert.assertFalse("Add a partition with unicode characters in name", - runHook(event)); - } - - @Test - public void testAddPartitionWithValidPartVal() { - - Partition p = new Partition(); - p.setValues(getPartValsWithValidCharacters()); - - PreAddPartitionEvent event = new PreAddPartitionEvent(p, null); - - Assert.assertTrue("Add a partition with unicode characters in name", - runHook(event)); - } - - @Test - public void testAppendPartitionWithUnicode() { - - Partition p = new Partition(); - p.setValues(getPartValsWithUnicode()); - - PreAddPartitionEvent event = new PreAddPartitionEvent(p, null); - - Assert.assertFalse("Append a partition with unicode characters in name", - runHook(event)); - } - - @Test - public void testAppendPartitionWithCommas() { - - Partition p = new Partition(); - p.setValues(getPartValsWithCommas()); - - PreAddPartitionEvent event = new PreAddPartitionEvent(p, null); - - Assert.assertFalse("Append a partition with unicode characters in name", - runHook(event)); - } - - @Test - public void testAppendPartitionWithValidCharacters() { - - Partition p = new Partition(); - p.setValues(getPartValsWithValidCharacters()); - - PreAddPartitionEvent event = new PreAddPartitionEvent(p, null); - - Assert.assertTrue("Append a partition with no unicode characters in name", - runHook(event)); - } - -} Index: metastore/src/test/org/apache/hadoop/hive/metastore/TestPartitionNameWhitelistValidation.java =================================================================== --- metastore/src/test/org/apache/hadoop/hive/metastore/TestPartitionNameWhitelistValidation.java (revision 0) +++ metastore/src/test/org/apache/hadoop/hive/metastore/TestPartitionNameWhitelistValidation.java (working copy) @@ -0,0 +1,146 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.metastore; + +import java.util.ArrayList; +import java.util.List; + +import junit.framework.Assert; +import junit.framework.TestCase; + +import org.apache.hadoop.hive.cli.CliSessionState; +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.ql.Driver; +import org.apache.hadoop.hive.ql.session.SessionState; +import org.apache.hadoop.hive.shims.ShimLoader; +import org.junit.Test; + +// Validate the metastore client call validatePartitionNameCharacters to ensure it throws +// an exception if partition fields contain Unicode characters or commas + +public class TestPartitionNameWhitelistValidation extends TestCase { + + private static final String partitionValidationPattern = "[\\x20-\\x7E&&[^,]]*"; + + private HiveConf hiveConf; + private HiveMetaStoreClient msc; + private Driver driver; + + @Override + protected void setUp() throws Exception { + super.setUp(); + System.setProperty(HiveConf.ConfVars.METASTORE_PARTITION_NAME_WHITELIST_PATTERN.varname, + partitionValidationPattern); + int port = MetaStoreUtils.findFreePort(); + MetaStoreUtils.startMetaStore(port, ShimLoader.getHadoopThriftAuthBridge()); + hiveConf = new HiveConf(this.getClass()); + hiveConf.setVar(HiveConf.ConfVars.METASTOREURIS, "thrift://localhost:" + port); + hiveConf.setIntVar(HiveConf.ConfVars.METASTORETHRIFTCONNECTIONRETRIES, 3); + SessionState.start(new CliSessionState(hiveConf)); + msc = new HiveMetaStoreClient(hiveConf, null); + driver = new Driver(hiveConf); + } + + // Runs an instance of DisallowUnicodePreEventListener + // Returns whether or not it succeeded + private boolean runValidation(List partVals) { + + try { + msc.validatePartitionNameCharacters(partVals); + } catch (Exception e) { + return false; + } + + return true; + } + + // Sample data + private List getPartValsWithUnicode() { + + List partVals = new ArrayList(); + partVals.add("klâwen"); + partVals.add("tägelîch"); + + return partVals; + + } + + private List getPartValsWithCommas() { + + List partVals = new ArrayList(); + partVals.add("a,b"); + partVals.add("c,d,e,f"); + + return partVals; + + } + + private List getPartValsWithValidCharacters() { + + List partVals = new ArrayList(); + partVals.add("part1"); + partVals.add("part2"); + + return partVals; + + } + + @Test + public void testAddPartitionWithCommas() { + + Assert.assertFalse("Add a partition with commas in name", + runValidation(getPartValsWithCommas())); + } + + @Test + public void testAddPartitionWithUnicode() { + + Assert.assertFalse("Add a partition with unicode characters in name", + runValidation(getPartValsWithUnicode())); + } + + @Test + public void testAddPartitionWithValidPartVal() { + + Assert.assertTrue("Add a partition with unicode characters in name", + runValidation(getPartValsWithValidCharacters())); + } + + @Test + public void testAppendPartitionWithUnicode() { + + Assert.assertFalse("Append a partition with unicode characters in name", + runValidation(getPartValsWithUnicode())); + } + + @Test + public void testAppendPartitionWithCommas() { + + Assert.assertFalse("Append a partition with unicode characters in name", + runValidation(getPartValsWithCommas())); + } + + @Test + public void testAppendPartitionWithValidCharacters() { + + Assert.assertTrue("Append a partition with no unicode characters in name", + runValidation(getPartValsWithValidCharacters())); + } + +} Index: ql/src/java/org/apache/hadoop/hive/ql/exec/MoveTask.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/exec/MoveTask.java (revision 1448321) +++ ql/src/java/org/apache/hadoop/hive/ql/exec/MoveTask.java (working copy) @@ -46,6 +46,7 @@ import org.apache.hadoop.hive.ql.lockmgr.HiveLock; import org.apache.hadoop.hive.ql.lockmgr.HiveLockManager; import org.apache.hadoop.hive.ql.lockmgr.HiveLockObj; +import org.apache.hadoop.hive.ql.metadata.Hive; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.metadata.Partition; import org.apache.hadoop.hive.ql.metadata.Table; @@ -393,6 +394,8 @@ } dc = null; // reset data container to prevent it being added again. } else { // static partitions + List partVals = Hive.getPvals(table.getPartCols(), tbd.getPartitionSpec()); + db.validatePartitionNameCharacters(partVals); db.loadPartition(new Path(tbd.getSourceDir()), tbd.getTable().getTableName(), tbd.getPartitionSpec(), tbd.getReplace(), tbd.getHoldDDLTime(), tbd.getInheritTableSpecs(), isSkewedStoredAsDirs(tbd)); Index: ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java (revision 1448321) +++ ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java (working copy) @@ -1355,6 +1355,12 @@ // No leaves in this directory LOG.info("NOT moving empty directory: " + s.getPath()); } else { + try { + validatePartitionNameCharacters( + Warehouse.getPartValuesFromPartName(s.getPath().getParent().toString())); + } catch (MetaException e) { + throw new HiveException(e); + } validPartitions.add(s.getPath().getParent()); } } @@ -1700,7 +1706,7 @@ } } - private static List getPvals(List partCols, + public static List getPvals(List partCols, Map partSpec) { List pvals = new ArrayList(); for (FieldSchema field : partCols) { @@ -1873,6 +1879,15 @@ return results; } + public void validatePartitionNameCharacters(List partVals) throws HiveException { + try { + getMSC().validatePartitionNameCharacters(partVals); + } catch (Exception e) { + LOG.error(StringUtils.stringifyException(e)); + throw new HiveException(e); + } + } + /** * Get the name of the current database * @return the current database name Index: ql/src/test/org/apache/hadoop/hive/ql/hooks/VerifyTableDirectoryIsEmptyHook.java =================================================================== --- ql/src/test/org/apache/hadoop/hive/ql/hooks/VerifyTableDirectoryIsEmptyHook.java (revision 0) +++ ql/src/test/org/apache/hadoop/hive/ql/hooks/VerifyTableDirectoryIsEmptyHook.java (working copy) @@ -0,0 +1,36 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.hooks; + +import java.io.IOException; + +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.ql.session.SessionState; + +// This hook verifies that the location of every output table is empty +public class VerifyTableDirectoryIsEmptyHook implements ExecuteWithHookContext { + + public void run(HookContext hookContext) throws IOException { + for (WriteEntity output : hookContext.getOutputs()) { + Path tableLocation = new Path(output.getTable().getDataLocation().toString()); + FileSystem fs = tableLocation.getFileSystem(SessionState.get().getConf()); + assert(fs.listStatus(tableLocation).length == 0); + } + } +} Index: ql/src/test/queries/clientnegative/add_partition_with_whitelist.q =================================================================== --- ql/src/test/queries/clientnegative/add_partition_with_whitelist.q (revision 1448321) +++ ql/src/test/queries/clientnegative/add_partition_with_whitelist.q (working copy) @@ -1,4 +1,3 @@ -SET hive.metastore.pre.event.listeners=org.apache.hadoop.hive.metastore.PartitionNameWhitelistPreEventListener; SET hive.metastore.partition.name.whitelist.pattern=[\\x20-\\x7E&&[^,]]* ; -- This pattern matches all printable ASCII characters (disallow unicode) and disallows commas Index: ql/src/test/queries/clientnegative/alter_partition_with_whitelist.q =================================================================== --- ql/src/test/queries/clientnegative/alter_partition_with_whitelist.q (revision 0) +++ ql/src/test/queries/clientnegative/alter_partition_with_whitelist.q (working copy) @@ -0,0 +1,9 @@ +SET hive.metastore.partition.name.whitelist.pattern=[\\x20-\\x7E&&[^,]]* ; +-- This pattern matches all printable ASCII characters (disallow unicode) and disallows commas + +CREATE TABLE part_whitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING); +SHOW PARTITIONS part_whitelist_test; + +ALTER TABLE part_whitelist_test ADD PARTITION (ds='1'); + +ALTER TABLE part_whitelist_test PARTITION (ds='1') rename to partition (ds='1,2,3'); Index: ql/src/test/queries/clientnegative/dynamic_partitions_with_whitelist.q =================================================================== --- ql/src/test/queries/clientnegative/dynamic_partitions_with_whitelist.q (revision 1448321) +++ ql/src/test/queries/clientnegative/dynamic_partitions_with_whitelist.q (working copy) @@ -1,5 +1,5 @@ -SET hive.metastore.pre.event.listeners=org.apache.hadoop.hive.metastore.PartitionNameWhitelistPreEventListener; -SET hive.metastore.partition.name.whitelist.pattern=[A-Za-z]*; +SET hive.metastore.partition.name.whitelist.pattern=[^9]*; +set hive.exec.failure.hooks=org.apache.hadoop.hive.ql.hooks.VerifyTableDirectoryIsEmptyHook; set hive.exec.dynamic.partition=true; set hive.exec.dynamic.partition.mode=nonstrict; @@ -10,5 +10,8 @@ load data local inpath '../data/files/srcbucket20.txt' INTO TABLE source_table partition(ds='2008-04-08', hr=11); -insert overwrite table dest_table partition (ds, hr) select key, value, hr from source_table where ds='2008-04-08'; +-- Tests creating dynamic partitions with characters not in the whitelist (i.e. 9) +-- If the directory is not empty the hook will throw an error, instead the error should come from the metastore +-- This shows that no dynamic partitions were created and left behind or had directories created +insert overwrite table dest_table partition (ds, hr) select key, hr, ds, value from source_table where ds='2008-04-08' order by value asc; Index: ql/src/test/queries/clientpositive/add_partition_no_whitelist.q =================================================================== --- ql/src/test/queries/clientpositive/add_partition_no_whitelist.q (revision 1448321) +++ ql/src/test/queries/clientpositive/add_partition_no_whitelist.q (working copy) @@ -1,5 +1,5 @@ -SET hive.metastore.pre.event.listeners= ; --- Test with PartitionNameWhitelistPreEventListener NOT registered +SET hive.metastore.partition.name.whitelist.pattern=; +-- Test with no partition name whitelist pattern CREATE TABLE part_nowhitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING); SHOW PARTITIONS part_nowhitelist_test; Index: ql/src/test/queries/clientpositive/add_partition_with_whitelist.q =================================================================== --- ql/src/test/queries/clientpositive/add_partition_with_whitelist.q (revision 1448321) +++ ql/src/test/queries/clientpositive/add_partition_with_whitelist.q (working copy) @@ -1,4 +1,3 @@ -SET hive.metastore.pre.event.listeners=org.apache.hadoop.hive.metastore.PartitionNameWhitelistPreEventListener; SET hive.metastore.partition.name.whitelist.pattern=[A-Za-z]*; -- This pattern matches only letters. Index: ql/src/test/queries/clientpositive/alter_partition_with_whitelist.q =================================================================== --- ql/src/test/queries/clientpositive/alter_partition_with_whitelist.q (revision 0) +++ ql/src/test/queries/clientpositive/alter_partition_with_whitelist.q (working copy) @@ -0,0 +1,9 @@ +SET hive.metastore.partition.name.whitelist.pattern=[A-Za-z]*; +-- This pattern matches only letters. + +CREATE TABLE part_whitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING); +SHOW PARTITIONS part_whitelist_test; + +ALTER TABLE part_whitelist_test ADD PARTITION (ds='Part'); + +ALTER TABLE part_whitelist_test PARTITION (ds='Part') rename to partition (ds='Apart'); Index: ql/src/test/results/clientnegative/alter_partition_with_whitelist.q.out =================================================================== --- ql/src/test/results/clientnegative/alter_partition_with_whitelist.q.out (revision 0) +++ ql/src/test/results/clientnegative/alter_partition_with_whitelist.q.out (working copy) @@ -0,0 +1,26 @@ +PREHOOK: query: -- This pattern matches all printable ASCII characters (disallow unicode) and disallows commas + +CREATE TABLE part_whitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING) +PREHOOK: type: CREATETABLE +POSTHOOK: query: -- This pattern matches all printable ASCII characters (disallow unicode) and disallows commas + +CREATE TABLE part_whitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: default@part_whitelist_test +PREHOOK: query: SHOW PARTITIONS part_whitelist_test +PREHOOK: type: SHOWPARTITIONS +POSTHOOK: query: SHOW PARTITIONS part_whitelist_test +POSTHOOK: type: SHOWPARTITIONS +PREHOOK: query: ALTER TABLE part_whitelist_test ADD PARTITION (ds='1') +PREHOOK: type: ALTERTABLE_ADDPARTS +PREHOOK: Input: default@part_whitelist_test +POSTHOOK: query: ALTER TABLE part_whitelist_test ADD PARTITION (ds='1') +POSTHOOK: type: ALTERTABLE_ADDPARTS +POSTHOOK: Input: default@part_whitelist_test +POSTHOOK: Output: default@part_whitelist_test@ds=1 +PREHOOK: query: ALTER TABLE part_whitelist_test PARTITION (ds='1') rename to partition (ds='1,2,3') +PREHOOK: type: ALTERTABLE_RENAMEPART +PREHOOK: Input: default@part_whitelist_test +PREHOOK: Output: default@part_whitelist_test@ds=1 +FAILED: Error in metadata: Unable to rename partition. +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask Index: ql/src/test/results/clientnegative/dynamic_partitions_with_whitelist.q.out =================================================================== --- ql/src/test/results/clientnegative/dynamic_partitions_with_whitelist.q.out (revision 1448321) +++ ql/src/test/results/clientnegative/dynamic_partitions_with_whitelist.q.out (working copy) @@ -11,5 +11,18 @@ PREHOOK: query: load data local inpath '../data/files/srcbucket20.txt' INTO TABLE source_table partition(ds='2008-04-08', hr=11) PREHOOK: type: LOAD PREHOOK: Output: default@source_table -Failed with exception MetaException(message:Partition value '2008-04-08' contains a character not matched by whitelist pattern '[A-Za-z]*'. (configure with hive.metastore.partition.name.whitelist.pattern)) +POSTHOOK: query: load data local inpath '../data/files/srcbucket20.txt' INTO TABLE source_table partition(ds='2008-04-08', hr=11) +POSTHOOK: type: LOAD +POSTHOOK: Output: default@source_table +POSTHOOK: Output: default@source_table@ds=2008-04-08/hr=11 +PREHOOK: query: -- Tests creating dynamic partitions with characters not in the whitelist (i.e. 9) +-- If the directory is not empty the hook will throw an error, instead the error should come from the metastore +-- This shows that no dynamic partitions were created and left behind or had directories created + +insert overwrite table dest_table partition (ds, hr) select key, hr, ds, value from source_table where ds='2008-04-08' order by value asc +PREHOOK: type: QUERY +PREHOOK: Input: default@source_table +PREHOOK: Input: default@source_table@ds=2008-04-08/hr=11 +PREHOOK: Output: default@dest_table +Failed with exception MetaException(message:Partition value 'val_129' contains a character not matched by whitelist pattern '[^9]*'. (configure with hive.metastore.partition.name.whitelist.pattern)) FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.MoveTask Index: ql/src/test/results/clientpositive/add_partition_no_whitelist.q.out =================================================================== --- ql/src/test/results/clientpositive/add_partition_no_whitelist.q.out (revision 1448321) +++ ql/src/test/results/clientpositive/add_partition_no_whitelist.q.out (working copy) @@ -1,8 +1,8 @@ -PREHOOK: query: -- Test with PartitionNameWhitelistPreEventListener NOT registered +PREHOOK: query: -- Test with no partition name whitelist pattern CREATE TABLE part_nowhitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING) PREHOOK: type: CREATETABLE -POSTHOOK: query: -- Test with PartitionNameWhitelistPreEventListener NOT registered +POSTHOOK: query: -- Test with no partition name whitelist pattern CREATE TABLE part_nowhitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING) POSTHOOK: type: CREATETABLE Index: ql/src/test/results/clientpositive/alter_partition_with_whitelist.q.out =================================================================== --- ql/src/test/results/clientpositive/alter_partition_with_whitelist.q.out (revision 0) +++ ql/src/test/results/clientpositive/alter_partition_with_whitelist.q.out (working copy) @@ -0,0 +1,30 @@ +PREHOOK: query: -- This pattern matches only letters. + +CREATE TABLE part_whitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING) +PREHOOK: type: CREATETABLE +POSTHOOK: query: -- This pattern matches only letters. + +CREATE TABLE part_whitelist_test (key STRING, value STRING) PARTITIONED BY (ds STRING) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: default@part_whitelist_test +PREHOOK: query: SHOW PARTITIONS part_whitelist_test +PREHOOK: type: SHOWPARTITIONS +POSTHOOK: query: SHOW PARTITIONS part_whitelist_test +POSTHOOK: type: SHOWPARTITIONS +PREHOOK: query: ALTER TABLE part_whitelist_test ADD PARTITION (ds='Part') +PREHOOK: type: ALTERTABLE_ADDPARTS +PREHOOK: Input: default@part_whitelist_test +POSTHOOK: query: ALTER TABLE part_whitelist_test ADD PARTITION (ds='Part') +POSTHOOK: type: ALTERTABLE_ADDPARTS +POSTHOOK: Input: default@part_whitelist_test +POSTHOOK: Output: default@part_whitelist_test@ds=Part +PREHOOK: query: ALTER TABLE part_whitelist_test PARTITION (ds='Part') rename to partition (ds='Apart') +PREHOOK: type: ALTERTABLE_RENAMEPART +PREHOOK: Input: default@part_whitelist_test +PREHOOK: Output: default@part_whitelist_test@ds=Part +POSTHOOK: query: ALTER TABLE part_whitelist_test PARTITION (ds='Part') rename to partition (ds='Apart') +POSTHOOK: type: ALTERTABLE_RENAMEPART +POSTHOOK: Input: default@part_whitelist_test +POSTHOOK: Input: default@part_whitelist_test@ds=Part +POSTHOOK: Output: default@part_whitelist_test@ds=Apart +POSTHOOK: Output: default@part_whitelist_test@ds=Part