http://git-wip-us.apache.org/repos/asf/hive/blob/cbb9233a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php b/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php index e76eb24..a6047bf 100644 --- a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php +++ b/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -14336,6 +14336,774 @@ class CommitTxnRequest { } +class GetValidWriteIdsRequest { + static $_TSPEC; + + /** + * @var string[] + */ + public $fullTableNames = null; + /** + * @var string + */ + public $validTxnList = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'fullTableNames', + 'type' => TType::LST, + 'etype' => TType::STRING, + 'elem' => array( + 'type' => TType::STRING, + ), + ), + 2 => array( + 'var' => 'validTxnList', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['fullTableNames'])) { + $this->fullTableNames = $vals['fullTableNames']; + } + if (isset($vals['validTxnList'])) { + $this->validTxnList = $vals['validTxnList']; + } + } + } + + public function getName() { + return 'GetValidWriteIdsRequest'; + } + + 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->fullTableNames = array(); + $_size490 = 0; + $_etype493 = 0; + $xfer += $input->readListBegin($_etype493, $_size490); + for ($_i494 = 0; $_i494 < $_size490; ++$_i494) + { + $elem495 = null; + $xfer += $input->readString($elem495); + $this->fullTableNames []= $elem495; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->validTxnList); + } 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('GetValidWriteIdsRequest'); + if ($this->fullTableNames !== null) { + if (!is_array($this->fullTableNames)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('fullTableNames', TType::LST, 1); + { + $output->writeListBegin(TType::STRING, count($this->fullTableNames)); + { + foreach ($this->fullTableNames as $iter496) + { + $xfer += $output->writeString($iter496); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->validTxnList !== null) { + $xfer += $output->writeFieldBegin('validTxnList', TType::STRING, 2); + $xfer += $output->writeString($this->validTxnList); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class TableValidWriteIds { + static $_TSPEC; + + /** + * @var string + */ + public $fullTableName = null; + /** + * @var int + */ + public $writeIdHighWaterMark = null; + /** + * @var int[] + */ + public $invalidWriteIds = null; + /** + * @var int + */ + public $minOpenWriteId = null; + /** + * @var string + */ + public $abortedBits = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'fullTableName', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'writeIdHighWaterMark', + 'type' => TType::I64, + ), + 3 => array( + 'var' => 'invalidWriteIds', + 'type' => TType::LST, + 'etype' => TType::I64, + 'elem' => array( + 'type' => TType::I64, + ), + ), + 4 => array( + 'var' => 'minOpenWriteId', + 'type' => TType::I64, + ), + 5 => array( + 'var' => 'abortedBits', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['fullTableName'])) { + $this->fullTableName = $vals['fullTableName']; + } + if (isset($vals['writeIdHighWaterMark'])) { + $this->writeIdHighWaterMark = $vals['writeIdHighWaterMark']; + } + if (isset($vals['invalidWriteIds'])) { + $this->invalidWriteIds = $vals['invalidWriteIds']; + } + if (isset($vals['minOpenWriteId'])) { + $this->minOpenWriteId = $vals['minOpenWriteId']; + } + if (isset($vals['abortedBits'])) { + $this->abortedBits = $vals['abortedBits']; + } + } + } + + public function getName() { + return 'TableValidWriteIds'; + } + + 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::STRING) { + $xfer += $input->readString($this->fullTableName); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::I64) { + $xfer += $input->readI64($this->writeIdHighWaterMark); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::LST) { + $this->invalidWriteIds = array(); + $_size497 = 0; + $_etype500 = 0; + $xfer += $input->readListBegin($_etype500, $_size497); + for ($_i501 = 0; $_i501 < $_size497; ++$_i501) + { + $elem502 = null; + $xfer += $input->readI64($elem502); + $this->invalidWriteIds []= $elem502; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::I64) { + $xfer += $input->readI64($this->minOpenWriteId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 5: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->abortedBits); + } 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('TableValidWriteIds'); + if ($this->fullTableName !== null) { + $xfer += $output->writeFieldBegin('fullTableName', TType::STRING, 1); + $xfer += $output->writeString($this->fullTableName); + $xfer += $output->writeFieldEnd(); + } + if ($this->writeIdHighWaterMark !== null) { + $xfer += $output->writeFieldBegin('writeIdHighWaterMark', TType::I64, 2); + $xfer += $output->writeI64($this->writeIdHighWaterMark); + $xfer += $output->writeFieldEnd(); + } + if ($this->invalidWriteIds !== null) { + if (!is_array($this->invalidWriteIds)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('invalidWriteIds', TType::LST, 3); + { + $output->writeListBegin(TType::I64, count($this->invalidWriteIds)); + { + foreach ($this->invalidWriteIds as $iter503) + { + $xfer += $output->writeI64($iter503); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->minOpenWriteId !== null) { + $xfer += $output->writeFieldBegin('minOpenWriteId', TType::I64, 4); + $xfer += $output->writeI64($this->minOpenWriteId); + $xfer += $output->writeFieldEnd(); + } + if ($this->abortedBits !== null) { + $xfer += $output->writeFieldBegin('abortedBits', TType::STRING, 5); + $xfer += $output->writeString($this->abortedBits); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class GetValidWriteIdsResponse { + static $_TSPEC; + + /** + * @var \metastore\TableValidWriteIds[] + */ + public $tblValidWriteIds = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'tblValidWriteIds', + 'type' => TType::LST, + 'etype' => TType::STRUCT, + 'elem' => array( + 'type' => TType::STRUCT, + 'class' => '\metastore\TableValidWriteIds', + ), + ), + ); + } + if (is_array($vals)) { + if (isset($vals['tblValidWriteIds'])) { + $this->tblValidWriteIds = $vals['tblValidWriteIds']; + } + } + } + + public function getName() { + return 'GetValidWriteIdsResponse'; + } + + 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->tblValidWriteIds = array(); + $_size504 = 0; + $_etype507 = 0; + $xfer += $input->readListBegin($_etype507, $_size504); + for ($_i508 = 0; $_i508 < $_size504; ++$_i508) + { + $elem509 = null; + $elem509 = new \metastore\TableValidWriteIds(); + $xfer += $elem509->read($input); + $this->tblValidWriteIds []= $elem509; + } + $xfer += $input->readListEnd(); + } 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('GetValidWriteIdsResponse'); + if ($this->tblValidWriteIds !== null) { + if (!is_array($this->tblValidWriteIds)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('tblValidWriteIds', TType::LST, 1); + { + $output->writeListBegin(TType::STRUCT, count($this->tblValidWriteIds)); + { + foreach ($this->tblValidWriteIds as $iter510) + { + $xfer += $iter510->write($output); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class AllocateTableWriteIdsRequest { + static $_TSPEC; + + /** + * @var int[] + */ + public $txnIds = null; + /** + * @var string + */ + public $dbName = null; + /** + * @var string + */ + public $tableName = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'txnIds', + 'type' => TType::LST, + 'etype' => TType::I64, + 'elem' => array( + 'type' => TType::I64, + ), + ), + 2 => array( + 'var' => 'dbName', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'tableName', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['txnIds'])) { + $this->txnIds = $vals['txnIds']; + } + if (isset($vals['dbName'])) { + $this->dbName = $vals['dbName']; + } + if (isset($vals['tableName'])) { + $this->tableName = $vals['tableName']; + } + } + } + + public function getName() { + return 'AllocateTableWriteIdsRequest'; + } + + 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->txnIds = array(); + $_size511 = 0; + $_etype514 = 0; + $xfer += $input->readListBegin($_etype514, $_size511); + for ($_i515 = 0; $_i515 < $_size511; ++$_i515) + { + $elem516 = null; + $xfer += $input->readI64($elem516); + $this->txnIds []= $elem516; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->dbName); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->tableName); + } 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('AllocateTableWriteIdsRequest'); + if ($this->txnIds !== null) { + if (!is_array($this->txnIds)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('txnIds', TType::LST, 1); + { + $output->writeListBegin(TType::I64, count($this->txnIds)); + { + foreach ($this->txnIds as $iter517) + { + $xfer += $output->writeI64($iter517); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->dbName !== null) { + $xfer += $output->writeFieldBegin('dbName', TType::STRING, 2); + $xfer += $output->writeString($this->dbName); + $xfer += $output->writeFieldEnd(); + } + if ($this->tableName !== null) { + $xfer += $output->writeFieldBegin('tableName', TType::STRING, 3); + $xfer += $output->writeString($this->tableName); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class TxnToWriteId { + static $_TSPEC; + + /** + * @var int + */ + public $txnId = null; + /** + * @var int + */ + public $writeId = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'txnId', + 'type' => TType::I64, + ), + 2 => array( + 'var' => 'writeId', + 'type' => TType::I64, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['txnId'])) { + $this->txnId = $vals['txnId']; + } + if (isset($vals['writeId'])) { + $this->writeId = $vals['writeId']; + } + } + } + + public function getName() { + return 'TxnToWriteId'; + } + + 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::I64) { + $xfer += $input->readI64($this->txnId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::I64) { + $xfer += $input->readI64($this->writeId); + } 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('TxnToWriteId'); + if ($this->txnId !== null) { + $xfer += $output->writeFieldBegin('txnId', TType::I64, 1); + $xfer += $output->writeI64($this->txnId); + $xfer += $output->writeFieldEnd(); + } + if ($this->writeId !== null) { + $xfer += $output->writeFieldBegin('writeId', TType::I64, 2); + $xfer += $output->writeI64($this->writeId); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class AllocateTableWriteIdsResponse { + static $_TSPEC; + + /** + * @var \metastore\TxnToWriteId[] + */ + public $txnToWriteIds = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'txnToWriteIds', + 'type' => TType::LST, + 'etype' => TType::STRUCT, + 'elem' => array( + 'type' => TType::STRUCT, + 'class' => '\metastore\TxnToWriteId', + ), + ), + ); + } + if (is_array($vals)) { + if (isset($vals['txnToWriteIds'])) { + $this->txnToWriteIds = $vals['txnToWriteIds']; + } + } + } + + public function getName() { + return 'AllocateTableWriteIdsResponse'; + } + + 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->txnToWriteIds = array(); + $_size518 = 0; + $_etype521 = 0; + $xfer += $input->readListBegin($_etype521, $_size518); + for ($_i522 = 0; $_i522 < $_size518; ++$_i522) + { + $elem523 = null; + $elem523 = new \metastore\TxnToWriteId(); + $xfer += $elem523->read($input); + $this->txnToWriteIds []= $elem523; + } + $xfer += $input->readListEnd(); + } 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('AllocateTableWriteIdsResponse'); + if ($this->txnToWriteIds !== null) { + if (!is_array($this->txnToWriteIds)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('txnToWriteIds', TType::LST, 1); + { + $output->writeListBegin(TType::STRUCT, count($this->txnToWriteIds)); + { + foreach ($this->txnToWriteIds as $iter524) + { + $xfer += $iter524->write($output); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class LockComponent { static $_TSPEC; @@ -14667,15 +15435,15 @@ class LockRequest { case 1: if ($ftype == TType::LST) { $this->component = array(); - $_size490 = 0; - $_etype493 = 0; - $xfer += $input->readListBegin($_etype493, $_size490); - for ($_i494 = 0; $_i494 < $_size490; ++$_i494) + $_size525 = 0; + $_etype528 = 0; + $xfer += $input->readListBegin($_etype528, $_size525); + for ($_i529 = 0; $_i529 < $_size525; ++$_i529) { - $elem495 = null; - $elem495 = new \metastore\LockComponent(); - $xfer += $elem495->read($input); - $this->component []= $elem495; + $elem530 = null; + $elem530 = new \metastore\LockComponent(); + $xfer += $elem530->read($input); + $this->component []= $elem530; } $xfer += $input->readListEnd(); } else { @@ -14731,9 +15499,9 @@ class LockRequest { { $output->writeListBegin(TType::STRUCT, count($this->component)); { - foreach ($this->component as $iter496) + foreach ($this->component as $iter531) { - $xfer += $iter496->write($output); + $xfer += $iter531->write($output); } } $output->writeListEnd(); @@ -15676,15 +16444,15 @@ class ShowLocksResponse { case 1: if ($ftype == TType::LST) { $this->locks = array(); - $_size497 = 0; - $_etype500 = 0; - $xfer += $input->readListBegin($_etype500, $_size497); - for ($_i501 = 0; $_i501 < $_size497; ++$_i501) + $_size532 = 0; + $_etype535 = 0; + $xfer += $input->readListBegin($_etype535, $_size532); + for ($_i536 = 0; $_i536 < $_size532; ++$_i536) { - $elem502 = null; - $elem502 = new \metastore\ShowLocksResponseElement(); - $xfer += $elem502->read($input); - $this->locks []= $elem502; + $elem537 = null; + $elem537 = new \metastore\ShowLocksResponseElement(); + $xfer += $elem537->read($input); + $this->locks []= $elem537; } $xfer += $input->readListEnd(); } else { @@ -15712,9 +16480,9 @@ class ShowLocksResponse { { $output->writeListBegin(TType::STRUCT, count($this->locks)); { - foreach ($this->locks as $iter503) + foreach ($this->locks as $iter538) { - $xfer += $iter503->write($output); + $xfer += $iter538->write($output); } } $output->writeListEnd(); @@ -15989,17 +16757,17 @@ class HeartbeatTxnRangeResponse { case 1: if ($ftype == TType::SET) { $this->aborted = array(); - $_size504 = 0; - $_etype507 = 0; - $xfer += $input->readSetBegin($_etype507, $_size504); - for ($_i508 = 0; $_i508 < $_size504; ++$_i508) + $_size539 = 0; + $_etype542 = 0; + $xfer += $input->readSetBegin($_etype542, $_size539); + for ($_i543 = 0; $_i543 < $_size539; ++$_i543) { - $elem509 = null; - $xfer += $input->readI64($elem509); - if (is_scalar($elem509)) { - $this->aborted[$elem509] = true; + $elem544 = null; + $xfer += $input->readI64($elem544); + if (is_scalar($elem544)) { + $this->aborted[$elem544] = true; } else { - $this->aborted []= $elem509; + $this->aborted []= $elem544; } } $xfer += $input->readSetEnd(); @@ -16010,17 +16778,17 @@ class HeartbeatTxnRangeResponse { case 2: if ($ftype == TType::SET) { $this->nosuch = array(); - $_size510 = 0; - $_etype513 = 0; - $xfer += $input->readSetBegin($_etype513, $_size510); - for ($_i514 = 0; $_i514 < $_size510; ++$_i514) + $_size545 = 0; + $_etype548 = 0; + $xfer += $input->readSetBegin($_etype548, $_size545); + for ($_i549 = 0; $_i549 < $_size545; ++$_i549) { - $elem515 = null; - $xfer += $input->readI64($elem515); - if (is_scalar($elem515)) { - $this->nosuch[$elem515] = true; + $elem550 = null; + $xfer += $input->readI64($elem550); + if (is_scalar($elem550)) { + $this->nosuch[$elem550] = true; } else { - $this->nosuch []= $elem515; + $this->nosuch []= $elem550; } } $xfer += $input->readSetEnd(); @@ -16049,12 +16817,12 @@ class HeartbeatTxnRangeResponse { { $output->writeSetBegin(TType::I64, count($this->aborted)); { - foreach ($this->aborted as $iter516 => $iter517) + foreach ($this->aborted as $iter551 => $iter552) { - if (is_scalar($iter517)) { - $xfer += $output->writeI64($iter516); + if (is_scalar($iter552)) { + $xfer += $output->writeI64($iter551); } else { - $xfer += $output->writeI64($iter517); + $xfer += $output->writeI64($iter552); } } } @@ -16070,12 +16838,12 @@ class HeartbeatTxnRangeResponse { { $output->writeSetBegin(TType::I64, count($this->nosuch)); { - foreach ($this->nosuch as $iter518 => $iter519) + foreach ($this->nosuch as $iter553 => $iter554) { - if (is_scalar($iter519)) { - $xfer += $output->writeI64($iter518); + if (is_scalar($iter554)) { + $xfer += $output->writeI64($iter553); } else { - $xfer += $output->writeI64($iter519); + $xfer += $output->writeI64($iter554); } } } @@ -16234,17 +17002,17 @@ class CompactionRequest { case 6: if ($ftype == TType::MAP) { $this->properties = array(); - $_size520 = 0; - $_ktype521 = 0; - $_vtype522 = 0; - $xfer += $input->readMapBegin($_ktype521, $_vtype522, $_size520); - for ($_i524 = 0; $_i524 < $_size520; ++$_i524) + $_size555 = 0; + $_ktype556 = 0; + $_vtype557 = 0; + $xfer += $input->readMapBegin($_ktype556, $_vtype557, $_size555); + for ($_i559 = 0; $_i559 < $_size555; ++$_i559) { - $key525 = ''; - $val526 = ''; - $xfer += $input->readString($key525); - $xfer += $input->readString($val526); - $this->properties[$key525] = $val526; + $key560 = ''; + $val561 = ''; + $xfer += $input->readString($key560); + $xfer += $input->readString($val561); + $this->properties[$key560] = $val561; } $xfer += $input->readMapEnd(); } else { @@ -16297,10 +17065,10 @@ class CompactionRequest { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->properties)); { - foreach ($this->properties as $kiter527 => $viter528) + foreach ($this->properties as $kiter562 => $viter563) { - $xfer += $output->writeString($kiter527); - $xfer += $output->writeString($viter528); + $xfer += $output->writeString($kiter562); + $xfer += $output->writeString($viter563); } } $output->writeMapEnd(); @@ -16887,15 +17655,15 @@ class ShowCompactResponse { case 1: if ($ftype == TType::LST) { $this->compacts = array(); - $_size529 = 0; - $_etype532 = 0; - $xfer += $input->readListBegin($_etype532, $_size529); - for ($_i533 = 0; $_i533 < $_size529; ++$_i533) + $_size564 = 0; + $_etype567 = 0; + $xfer += $input->readListBegin($_etype567, $_size564); + for ($_i568 = 0; $_i568 < $_size564; ++$_i568) { - $elem534 = null; - $elem534 = new \metastore\ShowCompactResponseElement(); - $xfer += $elem534->read($input); - $this->compacts []= $elem534; + $elem569 = null; + $elem569 = new \metastore\ShowCompactResponseElement(); + $xfer += $elem569->read($input); + $this->compacts []= $elem569; } $xfer += $input->readListEnd(); } else { @@ -16923,9 +17691,9 @@ class ShowCompactResponse { { $output->writeListBegin(TType::STRUCT, count($this->compacts)); { - foreach ($this->compacts as $iter535) + foreach ($this->compacts as $iter570) { - $xfer += $iter535->write($output); + $xfer += $iter570->write($output); } } $output->writeListEnd(); @@ -16947,6 +17715,10 @@ class AddDynamicPartitions { */ public $txnid = null; /** + * @var int + */ + public $writeid = null; + /** * @var string */ public $dbname = null; @@ -16971,14 +17743,18 @@ class AddDynamicPartitions { 'type' => TType::I64, ), 2 => array( + 'var' => 'writeid', + 'type' => TType::I64, + ), + 3 => array( 'var' => 'dbname', 'type' => TType::STRING, ), - 3 => array( + 4 => array( 'var' => 'tablename', 'type' => TType::STRING, ), - 4 => array( + 5 => array( 'var' => 'partitionnames', 'type' => TType::LST, 'etype' => TType::STRING, @@ -16986,7 +17762,7 @@ class AddDynamicPartitions { 'type' => TType::STRING, ), ), - 5 => array( + 6 => array( 'var' => 'operationType', 'type' => TType::I32, ), @@ -16996,6 +17772,9 @@ class AddDynamicPartitions { if (isset($vals['txnid'])) { $this->txnid = $vals['txnid']; } + if (isset($vals['writeid'])) { + $this->writeid = $vals['writeid']; + } if (isset($vals['dbname'])) { $this->dbname = $vals['dbname']; } @@ -17038,37 +17817,44 @@ class AddDynamicPartitions { } break; case 2: + if ($ftype == TType::I64) { + $xfer += $input->readI64($this->writeid); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: if ($ftype == TType::STRING) { $xfer += $input->readString($this->dbname); } else { $xfer += $input->skip($ftype); } break; - case 3: + case 4: if ($ftype == TType::STRING) { $xfer += $input->readString($this->tablename); } else { $xfer += $input->skip($ftype); } break; - case 4: + case 5: if ($ftype == TType::LST) { $this->partitionnames = array(); - $_size536 = 0; - $_etype539 = 0; - $xfer += $input->readListBegin($_etype539, $_size536); - for ($_i540 = 0; $_i540 < $_size536; ++$_i540) + $_size571 = 0; + $_etype574 = 0; + $xfer += $input->readListBegin($_etype574, $_size571); + for ($_i575 = 0; $_i575 < $_size571; ++$_i575) { - $elem541 = null; - $xfer += $input->readString($elem541); - $this->partitionnames []= $elem541; + $elem576 = null; + $xfer += $input->readString($elem576); + $this->partitionnames []= $elem576; } $xfer += $input->readListEnd(); } else { $xfer += $input->skip($ftype); } break; - case 5: + case 6: if ($ftype == TType::I32) { $xfer += $input->readI32($this->operationType); } else { @@ -17093,13 +17879,18 @@ class AddDynamicPartitions { $xfer += $output->writeI64($this->txnid); $xfer += $output->writeFieldEnd(); } + if ($this->writeid !== null) { + $xfer += $output->writeFieldBegin('writeid', TType::I64, 2); + $xfer += $output->writeI64($this->writeid); + $xfer += $output->writeFieldEnd(); + } if ($this->dbname !== null) { - $xfer += $output->writeFieldBegin('dbname', TType::STRING, 2); + $xfer += $output->writeFieldBegin('dbname', TType::STRING, 3); $xfer += $output->writeString($this->dbname); $xfer += $output->writeFieldEnd(); } if ($this->tablename !== null) { - $xfer += $output->writeFieldBegin('tablename', TType::STRING, 3); + $xfer += $output->writeFieldBegin('tablename', TType::STRING, 4); $xfer += $output->writeString($this->tablename); $xfer += $output->writeFieldEnd(); } @@ -17107,13 +17898,13 @@ class AddDynamicPartitions { if (!is_array($this->partitionnames)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); } - $xfer += $output->writeFieldBegin('partitionnames', TType::LST, 4); + $xfer += $output->writeFieldBegin('partitionnames', TType::LST, 5); { $output->writeListBegin(TType::STRING, count($this->partitionnames)); { - foreach ($this->partitionnames as $iter542) + foreach ($this->partitionnames as $iter577) { - $xfer += $output->writeString($iter542); + $xfer += $output->writeString($iter577); } } $output->writeListEnd(); @@ -17121,7 +17912,7 @@ class AddDynamicPartitions { $xfer += $output->writeFieldEnd(); } if ($this->operationType !== null) { - $xfer += $output->writeFieldBegin('operationType', TType::I32, 5); + $xfer += $output->writeFieldBegin('operationType', TType::I32, 6); $xfer += $output->writeI32($this->operationType); $xfer += $output->writeFieldEnd(); } @@ -17419,17 +18210,17 @@ class CreationMetadata { case 3: if ($ftype == TType::SET) { $this->tablesUsed = array(); - $_size543 = 0; - $_etype546 = 0; - $xfer += $input->readSetBegin($_etype546, $_size543); - for ($_i547 = 0; $_i547 < $_size543; ++$_i547) + $_size578 = 0; + $_etype581 = 0; + $xfer += $input->readSetBegin($_etype581, $_size578); + for ($_i582 = 0; $_i582 < $_size578; ++$_i582) { - $elem548 = null; - $xfer += $input->readString($elem548); - if (is_scalar($elem548)) { - $this->tablesUsed[$elem548] = true; + $elem583 = null; + $xfer += $input->readString($elem583); + if (is_scalar($elem583)) { + $this->tablesUsed[$elem583] = true; } else { - $this->tablesUsed []= $elem548; + $this->tablesUsed []= $elem583; } } $xfer += $input->readSetEnd(); @@ -17475,12 +18266,12 @@ class CreationMetadata { { $output->writeSetBegin(TType::STRING, count($this->tablesUsed)); { - foreach ($this->tablesUsed as $iter549 => $iter550) + foreach ($this->tablesUsed as $iter584 => $iter585) { - if (is_scalar($iter550)) { - $xfer += $output->writeString($iter549); + if (is_scalar($iter585)) { + $xfer += $output->writeString($iter584); } else { - $xfer += $output->writeString($iter550); + $xfer += $output->writeString($iter585); } } } @@ -17862,15 +18653,15 @@ class NotificationEventResponse { case 1: if ($ftype == TType::LST) { $this->events = array(); - $_size551 = 0; - $_etype554 = 0; - $xfer += $input->readListBegin($_etype554, $_size551); - for ($_i555 = 0; $_i555 < $_size551; ++$_i555) + $_size586 = 0; + $_etype589 = 0; + $xfer += $input->readListBegin($_etype589, $_size586); + for ($_i590 = 0; $_i590 < $_size586; ++$_i590) { - $elem556 = null; - $elem556 = new \metastore\NotificationEvent(); - $xfer += $elem556->read($input); - $this->events []= $elem556; + $elem591 = null; + $elem591 = new \metastore\NotificationEvent(); + $xfer += $elem591->read($input); + $this->events []= $elem591; } $xfer += $input->readListEnd(); } else { @@ -17898,9 +18689,9 @@ class NotificationEventResponse { { $output->writeListBegin(TType::STRUCT, count($this->events)); { - foreach ($this->events as $iter557) + foreach ($this->events as $iter592) { - $xfer += $iter557->write($output); + $xfer += $iter592->write($output); } } $output->writeListEnd(); @@ -18245,14 +19036,14 @@ class InsertEventRequestData { case 2: if ($ftype == TType::LST) { $this->filesAdded = array(); - $_size558 = 0; - $_etype561 = 0; - $xfer += $input->readListBegin($_etype561, $_size558); - for ($_i562 = 0; $_i562 < $_size558; ++$_i562) + $_size593 = 0; + $_etype596 = 0; + $xfer += $input->readListBegin($_etype596, $_size593); + for ($_i597 = 0; $_i597 < $_size593; ++$_i597) { - $elem563 = null; - $xfer += $input->readString($elem563); - $this->filesAdded []= $elem563; + $elem598 = null; + $xfer += $input->readString($elem598); + $this->filesAdded []= $elem598; } $xfer += $input->readListEnd(); } else { @@ -18262,14 +19053,14 @@ class InsertEventRequestData { case 3: if ($ftype == TType::LST) { $this->filesAddedChecksum = array(); - $_size564 = 0; - $_etype567 = 0; - $xfer += $input->readListBegin($_etype567, $_size564); - for ($_i568 = 0; $_i568 < $_size564; ++$_i568) + $_size599 = 0; + $_etype602 = 0; + $xfer += $input->readListBegin($_etype602, $_size599); + for ($_i603 = 0; $_i603 < $_size599; ++$_i603) { - $elem569 = null; - $xfer += $input->readString($elem569); - $this->filesAddedChecksum []= $elem569; + $elem604 = null; + $xfer += $input->readString($elem604); + $this->filesAddedChecksum []= $elem604; } $xfer += $input->readListEnd(); } else { @@ -18302,9 +19093,9 @@ class InsertEventRequestData { { $output->writeListBegin(TType::STRING, count($this->filesAdded)); { - foreach ($this->filesAdded as $iter570) + foreach ($this->filesAdded as $iter605) { - $xfer += $output->writeString($iter570); + $xfer += $output->writeString($iter605); } } $output->writeListEnd(); @@ -18319,9 +19110,9 @@ class InsertEventRequestData { { $output->writeListBegin(TType::STRING, count($this->filesAddedChecksum)); { - foreach ($this->filesAddedChecksum as $iter571) + foreach ($this->filesAddedChecksum as $iter606) { - $xfer += $output->writeString($iter571); + $xfer += $output->writeString($iter606); } } $output->writeListEnd(); @@ -18539,14 +19330,14 @@ class FireEventRequest { case 5: if ($ftype == TType::LST) { $this->partitionVals = array(); - $_size572 = 0; - $_etype575 = 0; - $xfer += $input->readListBegin($_etype575, $_size572); - for ($_i576 = 0; $_i576 < $_size572; ++$_i576) + $_size607 = 0; + $_etype610 = 0; + $xfer += $input->readListBegin($_etype610, $_size607); + for ($_i611 = 0; $_i611 < $_size607; ++$_i611) { - $elem577 = null; - $xfer += $input->readString($elem577); - $this->partitionVals []= $elem577; + $elem612 = null; + $xfer += $input->readString($elem612); + $this->partitionVals []= $elem612; } $xfer += $input->readListEnd(); } else { @@ -18597,9 +19388,9 @@ class FireEventRequest { { $output->writeListBegin(TType::STRING, count($this->partitionVals)); { - foreach ($this->partitionVals as $iter578) + foreach ($this->partitionVals as $iter613) { - $xfer += $output->writeString($iter578); + $xfer += $output->writeString($iter613); } } $output->writeListEnd(); @@ -18827,18 +19618,18 @@ class GetFileMetadataByExprResult { case 1: if ($ftype == TType::MAP) { $this->metadata = array(); - $_size579 = 0; - $_ktype580 = 0; - $_vtype581 = 0; - $xfer += $input->readMapBegin($_ktype580, $_vtype581, $_size579); - for ($_i583 = 0; $_i583 < $_size579; ++$_i583) + $_size614 = 0; + $_ktype615 = 0; + $_vtype616 = 0; + $xfer += $input->readMapBegin($_ktype615, $_vtype616, $_size614); + for ($_i618 = 0; $_i618 < $_size614; ++$_i618) { - $key584 = 0; - $val585 = new \metastore\MetadataPpdResult(); - $xfer += $input->readI64($key584); - $val585 = new \metastore\MetadataPpdResult(); - $xfer += $val585->read($input); - $this->metadata[$key584] = $val585; + $key619 = 0; + $val620 = new \metastore\MetadataPpdResult(); + $xfer += $input->readI64($key619); + $val620 = new \metastore\MetadataPpdResult(); + $xfer += $val620->read($input); + $this->metadata[$key619] = $val620; } $xfer += $input->readMapEnd(); } else { @@ -18873,10 +19664,10 @@ class GetFileMetadataByExprResult { { $output->writeMapBegin(TType::I64, TType::STRUCT, count($this->metadata)); { - foreach ($this->metadata as $kiter586 => $viter587) + foreach ($this->metadata as $kiter621 => $viter622) { - $xfer += $output->writeI64($kiter586); - $xfer += $viter587->write($output); + $xfer += $output->writeI64($kiter621); + $xfer += $viter622->write($output); } } $output->writeMapEnd(); @@ -18978,14 +19769,14 @@ class GetFileMetadataByExprRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size588 = 0; - $_etype591 = 0; - $xfer += $input->readListBegin($_etype591, $_size588); - for ($_i592 = 0; $_i592 < $_size588; ++$_i592) + $_size623 = 0; + $_etype626 = 0; + $xfer += $input->readListBegin($_etype626, $_size623); + for ($_i627 = 0; $_i627 < $_size623; ++$_i627) { - $elem593 = null; - $xfer += $input->readI64($elem593); - $this->fileIds []= $elem593; + $elem628 = null; + $xfer += $input->readI64($elem628); + $this->fileIds []= $elem628; } $xfer += $input->readListEnd(); } else { @@ -19034,9 +19825,9 @@ class GetFileMetadataByExprRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter594) + foreach ($this->fileIds as $iter629) { - $xfer += $output->writeI64($iter594); + $xfer += $output->writeI64($iter629); } } $output->writeListEnd(); @@ -19130,17 +19921,17 @@ class GetFileMetadataResult { case 1: if ($ftype == TType::MAP) { $this->metadata = array(); - $_size595 = 0; - $_ktype596 = 0; - $_vtype597 = 0; - $xfer += $input->readMapBegin($_ktype596, $_vtype597, $_size595); - for ($_i599 = 0; $_i599 < $_size595; ++$_i599) + $_size630 = 0; + $_ktype631 = 0; + $_vtype632 = 0; + $xfer += $input->readMapBegin($_ktype631, $_vtype632, $_size630); + for ($_i634 = 0; $_i634 < $_size630; ++$_i634) { - $key600 = 0; - $val601 = ''; - $xfer += $input->readI64($key600); - $xfer += $input->readString($val601); - $this->metadata[$key600] = $val601; + $key635 = 0; + $val636 = ''; + $xfer += $input->readI64($key635); + $xfer += $input->readString($val636); + $this->metadata[$key635] = $val636; } $xfer += $input->readMapEnd(); } else { @@ -19175,10 +19966,10 @@ class GetFileMetadataResult { { $output->writeMapBegin(TType::I64, TType::STRING, count($this->metadata)); { - foreach ($this->metadata as $kiter602 => $viter603) + foreach ($this->metadata as $kiter637 => $viter638) { - $xfer += $output->writeI64($kiter602); - $xfer += $output->writeString($viter603); + $xfer += $output->writeI64($kiter637); + $xfer += $output->writeString($viter638); } } $output->writeMapEnd(); @@ -19247,14 +20038,14 @@ class GetFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size604 = 0; - $_etype607 = 0; - $xfer += $input->readListBegin($_etype607, $_size604); - for ($_i608 = 0; $_i608 < $_size604; ++$_i608) + $_size639 = 0; + $_etype642 = 0; + $xfer += $input->readListBegin($_etype642, $_size639); + for ($_i643 = 0; $_i643 < $_size639; ++$_i643) { - $elem609 = null; - $xfer += $input->readI64($elem609); - $this->fileIds []= $elem609; + $elem644 = null; + $xfer += $input->readI64($elem644); + $this->fileIds []= $elem644; } $xfer += $input->readListEnd(); } else { @@ -19282,9 +20073,9 @@ class GetFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter610) + foreach ($this->fileIds as $iter645) { - $xfer += $output->writeI64($iter610); + $xfer += $output->writeI64($iter645); } } $output->writeListEnd(); @@ -19424,14 +20215,14 @@ class PutFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size611 = 0; - $_etype614 = 0; - $xfer += $input->readListBegin($_etype614, $_size611); - for ($_i615 = 0; $_i615 < $_size611; ++$_i615) + $_size646 = 0; + $_etype649 = 0; + $xfer += $input->readListBegin($_etype649, $_size646); + for ($_i650 = 0; $_i650 < $_size646; ++$_i650) { - $elem616 = null; - $xfer += $input->readI64($elem616); - $this->fileIds []= $elem616; + $elem651 = null; + $xfer += $input->readI64($elem651); + $this->fileIds []= $elem651; } $xfer += $input->readListEnd(); } else { @@ -19441,14 +20232,14 @@ class PutFileMetadataRequest { case 2: if ($ftype == TType::LST) { $this->metadata = array(); - $_size617 = 0; - $_etype620 = 0; - $xfer += $input->readListBegin($_etype620, $_size617); - for ($_i621 = 0; $_i621 < $_size617; ++$_i621) + $_size652 = 0; + $_etype655 = 0; + $xfer += $input->readListBegin($_etype655, $_size652); + for ($_i656 = 0; $_i656 < $_size652; ++$_i656) { - $elem622 = null; - $xfer += $input->readString($elem622); - $this->metadata []= $elem622; + $elem657 = null; + $xfer += $input->readString($elem657); + $this->metadata []= $elem657; } $xfer += $input->readListEnd(); } else { @@ -19483,9 +20274,9 @@ class PutFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter623) + foreach ($this->fileIds as $iter658) { - $xfer += $output->writeI64($iter623); + $xfer += $output->writeI64($iter658); } } $output->writeListEnd(); @@ -19500,9 +20291,9 @@ class PutFileMetadataRequest { { $output->writeListBegin(TType::STRING, count($this->metadata)); { - foreach ($this->metadata as $iter624) + foreach ($this->metadata as $iter659) { - $xfer += $output->writeString($iter624); + $xfer += $output->writeString($iter659); } } $output->writeListEnd(); @@ -19621,14 +20412,14 @@ class ClearFileMetadataRequest { case 1: if ($ftype == TType::LST) { $this->fileIds = array(); - $_size625 = 0; - $_etype628 = 0; - $xfer += $input->readListBegin($_etype628, $_size625); - for ($_i629 = 0; $_i629 < $_size625; ++$_i629) + $_size660 = 0; + $_etype663 = 0; + $xfer += $input->readListBegin($_etype663, $_size660); + for ($_i664 = 0; $_i664 < $_size660; ++$_i664) { - $elem630 = null; - $xfer += $input->readI64($elem630); - $this->fileIds []= $elem630; + $elem665 = null; + $xfer += $input->readI64($elem665); + $this->fileIds []= $elem665; } $xfer += $input->readListEnd(); } else { @@ -19656,9 +20447,9 @@ class ClearFileMetadataRequest { { $output->writeListBegin(TType::I64, count($this->fileIds)); { - foreach ($this->fileIds as $iter631) + foreach ($this->fileIds as $iter666) { - $xfer += $output->writeI64($iter631); + $xfer += $output->writeI64($iter666); } } $output->writeListEnd(); @@ -19942,15 +20733,15 @@ class GetAllFunctionsResponse { case 1: if ($ftype == TType::LST) { $this->functions = array(); - $_size632 = 0; - $_etype635 = 0; - $xfer += $input->readListBegin($_etype635, $_size632); - for ($_i636 = 0; $_i636 < $_size632; ++$_i636) + $_size667 = 0; + $_etype670 = 0; + $xfer += $input->readListBegin($_etype670, $_size667); + for ($_i671 = 0; $_i671 < $_size667; ++$_i671) { - $elem637 = null; - $elem637 = new \metastore\Function(); - $xfer += $elem637->read($input); - $this->functions []= $elem637; + $elem672 = null; + $elem672 = new \metastore\Function(); + $xfer += $elem672->read($input); + $this->functions []= $elem672; } $xfer += $input->readListEnd(); } else { @@ -19978,9 +20769,9 @@ class GetAllFunctionsResponse { { $output->writeListBegin(TType::STRUCT, count($this->functions)); { - foreach ($this->functions as $iter638) + foreach ($this->functions as $iter673) { - $xfer += $iter638->write($output); + $xfer += $iter673->write($output); } } $output->writeListEnd(); @@ -20044,14 +20835,14 @@ class ClientCapabilities { case 1: if ($ftype == TType::LST) { $this->values = array(); - $_size639 = 0; - $_etype642 = 0; - $xfer += $input->readListBegin($_etype642, $_size639); - for ($_i643 = 0; $_i643 < $_size639; ++$_i643) + $_size674 = 0; + $_etype677 = 0; + $xfer += $input->readListBegin($_etype677, $_size674); + for ($_i678 = 0; $_i678 < $_size674; ++$_i678) { - $elem644 = null; - $xfer += $input->readI32($elem644); - $this->values []= $elem644; + $elem679 = null; + $xfer += $input->readI32($elem679); + $this->values []= $elem679; } $xfer += $input->readListEnd(); } else { @@ -20079,9 +20870,9 @@ class ClientCapabilities { { $output->writeListBegin(TType::I32, count($this->values)); { - foreach ($this->values as $iter645) + foreach ($this->values as $iter680) { - $xfer += $output->writeI32($iter645); + $xfer += $output->writeI32($iter680); } } $output->writeListEnd(); @@ -20381,14 +21172,14 @@ class GetTablesRequest { case 2: if ($ftype == TType::LST) { $this->tblNames = array(); - $_size646 = 0; - $_etype649 = 0; - $xfer += $input->readListBegin($_etype649, $_size646); - for ($_i650 = 0; $_i650 < $_size646; ++$_i650) + $_size681 = 0; + $_etype684 = 0; + $xfer += $input->readListBegin($_etype684, $_size681); + for ($_i685 = 0; $_i685 < $_size681; ++$_i685) { - $elem651 = null; - $xfer += $input->readString($elem651); - $this->tblNames []= $elem651; + $elem686 = null; + $xfer += $input->readString($elem686); + $this->tblNames []= $elem686; } $xfer += $input->readListEnd(); } else { @@ -20429,9 +21220,9 @@ class GetTablesRequest { { $output->writeListBegin(TType::STRING, count($this->tblNames)); { - foreach ($this->tblNames as $iter652) + foreach ($this->tblNames as $iter687) { - $xfer += $output->writeString($iter652); + $xfer += $output->writeString($iter687); } } $output->writeListEnd(); @@ -20504,15 +21295,15 @@ class GetTablesResult { case 1: if ($ftype == TType::LST) { $this->tables = array(); - $_size653 = 0; - $_etype656 = 0; - $xfer += $input->readListBegin($_etype656, $_size653); - for ($_i657 = 0; $_i657 < $_size653; ++$_i657) + $_size688 = 0; + $_etype691 = 0; + $xfer += $input->readListBegin($_etype691, $_size688); + for ($_i692 = 0; $_i692 < $_size688; ++$_i692) { - $elem658 = null; - $elem658 = new \metastore\Table(); - $xfer += $elem658->read($input); - $this->tables []= $elem658; + $elem693 = null; + $elem693 = new \metastore\Table(); + $xfer += $elem693->read($input); + $this->tables []= $elem693; } $xfer += $input->readListEnd(); } else { @@ -20540,9 +21331,9 @@ class GetTablesResult { { $output->writeListBegin(TType::STRUCT, count($this->tables)); { - foreach ($this->tables as $iter659) + foreach ($this->tables as $iter694) { - $xfer += $iter659->write($output); + $xfer += $iter694->write($output); } } $output->writeListEnd(); @@ -20920,17 +21711,17 @@ class Materialization { case 1: if ($ftype == TType::SET) { $this->tablesUsed = array(); - $_size660 = 0; - $_etype663 = 0; - $xfer += $input->readSetBegin($_etype663, $_size660); - for ($_i664 = 0; $_i664 < $_size660; ++$_i664) + $_size695 = 0; + $_etype698 = 0; + $xfer += $input->readSetBegin($_etype698, $_size695); + for ($_i699 = 0; $_i699 < $_size695; ++$_i699) { - $elem665 = null; - $xfer += $input->readString($elem665); - if (is_scalar($elem665)) { - $this->tablesUsed[$elem665] = true; + $elem700 = null; + $xfer += $input->readString($elem700); + if (is_scalar($elem700)) { + $this->tablesUsed[$elem700] = true; } else { - $this->tablesUsed []= $elem665; + $this->tablesUsed []= $elem700; } } $xfer += $input->readSetEnd(); @@ -20973,12 +21764,12 @@ class Materialization { { $output->writeSetBegin(TType::STRING, count($this->tablesUsed)); { - foreach ($this->tablesUsed as $iter666 => $iter667) + foreach ($this->tablesUsed as $iter701 => $iter702) { - if (is_scalar($iter667)) { - $xfer += $output->writeString($iter666); + if (is_scalar($iter702)) { + $xfer += $output->writeString($iter701); } else { - $xfer += $output->writeString($iter667); + $xfer += $output->writeString($iter702); } } } @@ -22245,15 +23036,15 @@ class WMFullResourcePlan { case 2: if ($ftype == TType::LST) { $this->pools = array(); - $_size668 = 0; - $_etype671 = 0; - $xfer += $input->readListBegin($_etype671, $_size668); - for ($_i672 = 0; $_i672 < $_size668; ++$_i672) + $_size703 = 0; + $_etype706 = 0; + $xfer += $input->readListBegin($_etype706, $_size703); + for ($_i707 = 0; $_i707 < $_size703; ++$_i707) { - $elem673 = null; - $elem673 = new \metastore\WMPool(); - $xfer += $elem673->read($input); - $this->pools []= $elem673; + $elem708 = null; + $elem708 = new \metastore\WMPool(); + $xfer += $elem708->read($input); + $this->pools []= $elem708; } $xfer += $input->readListEnd(); } else { @@ -22263,15 +23054,15 @@ class WMFullResourcePlan { case 3: if ($ftype == TType::LST) { $this->mappings = array(); - $_size674 = 0; - $_etype677 = 0; - $xfer += $input->readListBegin($_etype677, $_size674); - for ($_i678 = 0; $_i678 < $_size674; ++$_i678) + $_size709 = 0; + $_etype712 = 0; + $xfer += $input->readListBegin($_etype712, $_size709); + for ($_i713 = 0; $_i713 < $_size709; ++$_i713) { - $elem679 = null; - $elem679 = new \metastore\WMMapping(); - $xfer += $elem679->read($input); - $this->mappings []= $elem679; + $elem714 = null; + $elem714 = new \metastore\WMMapping(); + $xfer += $elem714->read($input); + $this->mappings []= $elem714; } $xfer += $input->readListEnd(); } else { @@ -22281,15 +23072,15 @@ class WMFullResourcePlan { case 4: if ($ftype == TType::LST) { $this->triggers = array(); - $_size680 = 0; - $_etype683 = 0; - $xfer += $input->readListBegin($_etype683, $_size680); - for ($_i684 = 0; $_i684 < $_size680; ++$_i684) + $_size715 = 0; + $_etype718 = 0; + $xfer += $input->readListBegin($_etype718, $_size715); + for ($_i719 = 0; $_i719 < $_size715; ++$_i719) { - $elem685 = null; - $elem685 = new \metastore\WMTrigger(); - $xfer += $elem685->read($input); - $this->triggers []= $elem685; + $elem720 = null; + $elem720 = new \metastore\WMTrigger(); + $xfer += $elem720->read($input); + $this->triggers []= $elem720; } $xfer += $input->readListEnd(); } else { @@ -22299,15 +23090,15 @@ class WMFullResourcePlan { case 5: if ($ftype == TType::LST) { $this->poolTriggers = array(); - $_size686 = 0; - $_etype689 = 0; - $xfer += $input->readListBegin($_etype689, $_size686); - for ($_i690 = 0; $_i690 < $_size686; ++$_i690) + $_size721 = 0; + $_etype724 = 0; + $xfer += $input->readListBegin($_etype724, $_size721); + for ($_i725 = 0; $_i725 < $_size721; ++$_i725) { - $elem691 = null; - $elem691 = new \metastore\WMPoolTrigger(); - $xfer += $elem691->read($input); - $this->poolTriggers []= $elem691; + $elem726 = null; + $elem726 = new \metastore\WMPoolTrigger(); + $xfer += $elem726->read($input); + $this->poolTriggers []= $elem726; } $xfer += $input->readListEnd(); } else { @@ -22343,9 +23134,9 @@ class WMFullResourcePlan { { $output->writeListBegin(TType::STRUCT, count($this->pools)); { - foreach ($this->pools as $iter692) + foreach ($this->pools as $iter727) { - $xfer += $iter692->write($output); + $xfer += $iter727->write($output); } } $output->writeListEnd(); @@ -22360,9 +23151,9 @@ class WMFullResourcePlan { { $output->writeListBegin(TType::STRUCT, count($this->mappings)); { - foreach ($this->mappings as $iter693) + foreach ($this->mappings as $iter728) { - $xfer += $iter693->write($output); + $xfer += $iter728->write($output); } } $output->writeListEnd(); @@ -22377,9 +23168,9 @@ class WMFullResourcePlan { { $output->writeListBegin(TType::STRUCT, count($this->triggers)); { - foreach ($this->triggers as $iter694) + foreach ($this->triggers as $iter729) { - $xfer += $iter694->write($output); + $xfer += $iter729->write($output); } } $output->writeListEnd(); @@ -22394,9 +23185,9 @@ class WMFullResourcePlan { { $output->writeListBegin(TType::STRUCT, count($this->poolTriggers)); { - foreach ($this->poolTriggers as $iter695) + foreach ($this->poolTriggers as $iter730) { - $xfer += $iter695->write($output); + $xfer += $iter730->write($output); } } $output->writeListEnd(); @@ -22949,15 +23740,15 @@ class WMGetAllResourcePlanResponse { case 1: if ($ftype == TType::LST) { $this->resourcePlans = array(); - $_size696 = 0; - $_etype699 = 0; - $xfer += $input->readListBegin($_etype699, $_size696); - for ($_i700 = 0; $_i700 < $_size696; ++$_i700) + $_size731 = 0; + $_etype734 = 0; + $xfer += $input->readListBegin($_etype734, $_size731); + for ($_i735 = 0; $_i735 < $_size731; ++$_i735) { - $elem701 = null; - $elem701 = new \metastore\WMResourcePlan(); - $xfer += $elem701->read($input); - $this->resourcePlans []= $elem701; + $elem736 = null; + $elem736 = new \metastore\WMResourcePlan(); + $xfer += $elem736->read($input); + $this->resourcePlans []= $elem736; } $xfer += $input->readListEnd(); } else { @@ -22985,9 +23776,9 @@ class WMGetAllResourcePlanResponse { { $output->writeListBegin(TType::STRUCT, count($this->resourcePlans)); { - foreach ($this->resourcePlans as $iter702) + foreach ($this->resourcePlans as $iter737) { - $xfer += $iter702->write($output); + $xfer += $iter737->write($output); } } $output->writeListEnd(); @@ -23393,14 +24184,14 @@ class WMValidateResourcePlanResponse { case 1: if ($ftype == TType::LST) { $this->errors = array(); - $_size703 = 0; - $_etype706 = 0; - $xfer += $input->readListBegin($_etype706, $_size703); - for ($_i707 = 0; $_i707 < $_size703; ++$_i707) + $_size738 = 0; + $_etype741 = 0; + $xfer += $input->readListBegin($_etype741, $_size738); + for ($_i742 = 0; $_i742 < $_size738; ++$_i742) { - $elem708 = null; - $xfer += $input->readString($elem708); - $this->errors []= $elem708; + $elem743 = null; + $xfer += $input->readString($elem743); + $this->errors []= $elem743; } $xfer += $input->readListEnd(); } else { @@ -23410,14 +24201,14 @@ class WMValidateResourcePlanResponse { case 2: if ($ftype == TType::LST) { $this->warnings = array(); - $_size709 = 0; - $_etype712 = 0; - $xfer += $input->readListBegin($_etype712, $_size709); - for ($_i713 = 0; $_i713 < $_size709; ++$_i713) + $_size744 = 0; + $_etype747 = 0; + $xfer += $input->readListBegin($_etype747, $_size744); + for ($_i748 = 0; $_i748 < $_size744; ++$_i748) { - $elem714 = null; - $xfer += $input->readString($elem714); - $this->warnings []= $elem714; + $elem749 = null; + $xfer += $input->readString($elem749); + $this->warnings []= $elem749; } $xfer += $input->readListEnd(); } else { @@ -23445,9 +24236,9 @@ class WMValidateResourcePlanResponse { { $output->writeListBegin(TType::STRING, count($this->errors)); { - foreach ($this->errors as $iter715) + foreach ($this->errors as $iter750) { - $xfer += $output->writeString($iter715); + $xfer += $output->writeString($iter750); } } $output->writeListEnd(); @@ -23462,9 +24253,9 @@ class WMValidateResourcePlanResponse { { $output->writeListBegin(TType::STRING, count($this->warnings)); { - foreach ($this->warnings as $iter716) + foreach ($this->warnings as $iter751) { - $xfer += $output->writeString($iter716); + $xfer += $output->writeString($iter751); } } $output->writeListEnd(); @@ -24137,15 +24928,15 @@ class WMGetTriggersForResourePlanResponse { case 1: if ($ftype == TType::LST) { $this->triggers = array(); - $_size717 = 0; - $_etype720 = 0; - $xfer += $input->readListBegin($_etype720, $_size717); - for ($_i721 = 0; $_i721 < $_size717; ++$_i721) + $_size752 = 0; + $_etype755 = 0; + $xfer += $input->readListBegin($_etype755, $_size752); + for ($_i756 = 0; $_i756 < $_size752; ++$_i756) { - $elem722 = null; - $elem722 = new \metastore\WMTrigger(); - $xfer += $elem722->read($input); - $this->triggers []= $elem722; + $elem757 = null; + $elem757 = new \metastore\WMTrigger(); + $xfer += $elem757->read($input); + $this->triggers []= $elem757; } $xfer += $input->readListEnd(); } else { @@ -24173,9 +24964,9 @@ class WMGetTriggersForResourePlanResponse { { $output->writeListBegin(TType::STRUCT, count($this->triggers)); { - foreach ($this->triggers as $iter723) + foreach ($this->triggers as $iter758) { - $xfer += $iter723->write($output); + $xfer += $iter758->write($output); } } $output->writeListEnd();
http://git-wip-us.apache.org/repos/asf/hive/blob/cbb9233a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index c958e97..b3a0524 100755 --- a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -167,6 +167,8 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' void abort_txn(AbortTxnRequest rqst)') print(' void abort_txns(AbortTxnsRequest rqst)') print(' void commit_txn(CommitTxnRequest rqst)') + print(' GetValidWriteIdsResponse get_valid_write_ids(GetValidWriteIdsRequest rqst)') + print(' AllocateTableWriteIdsResponse allocate_table_write_ids(AllocateTableWriteIdsRequest rqst)') print(' LockResponse lock(LockRequest rqst)') print(' LockResponse check_lock(CheckLockRequest rqst)') print(' void unlock(UnlockRequest rqst)') @@ -1133,6 +1135,18 @@ elif cmd == 'commit_txn': sys.exit(1) pp.pprint(client.commit_txn(eval(args[0]),)) +elif cmd == 'get_valid_write_ids': + if len(args) != 1: + print('get_valid_write_ids requires 1 args') + sys.exit(1) + pp.pprint(client.get_valid_write_ids(eval(args[0]),)) + +elif cmd == 'allocate_table_write_ids': + if len(args) != 1: + print('allocate_table_write_ids requires 1 args') + sys.exit(1) + pp.pprint(client.allocate_table_write_ids(eval(args[0]),)) + elif cmd == 'lock': if len(args) != 1: print('lock requires 1 args')
