You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by se...@apache.org on 2018/07/03 17:47:50 UTC
[22/46] hive git commit: HIVE-19267: Replicate ACID/MM tables write
operations (Mahesh Kumar Behera, reviewed by Sankar Hariappan)
http://git-wip-us.apache.org/repos/asf/hive/blob/f519db7e/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 a29ebb7..93b5780 100644
--- a/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php
+++ b/standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php
@@ -16558,6 +16558,10 @@ class CommitTxnRequest {
* @var string
*/
public $replPolicy = null;
+ /**
+ * @var \metastore\WriteEventInfo[]
+ */
+ public $writeEventInfos = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
@@ -16570,6 +16574,15 @@ class CommitTxnRequest {
'var' => 'replPolicy',
'type' => TType::STRING,
),
+ 3 => array(
+ 'var' => 'writeEventInfos',
+ 'type' => TType::LST,
+ 'etype' => TType::STRUCT,
+ 'elem' => array(
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\WriteEventInfo',
+ ),
+ ),
);
}
if (is_array($vals)) {
@@ -16579,6 +16592,9 @@ class CommitTxnRequest {
if (isset($vals['replPolicy'])) {
$this->replPolicy = $vals['replPolicy'];
}
+ if (isset($vals['writeEventInfos'])) {
+ $this->writeEventInfos = $vals['writeEventInfos'];
+ }
}
}
@@ -16615,6 +16631,24 @@ class CommitTxnRequest {
$xfer += $input->skip($ftype);
}
break;
+ case 3:
+ if ($ftype == TType::LST) {
+ $this->writeEventInfos = array();
+ $_size523 = 0;
+ $_etype526 = 0;
+ $xfer += $input->readListBegin($_etype526, $_size523);
+ for ($_i527 = 0; $_i527 < $_size523; ++$_i527)
+ {
+ $elem528 = null;
+ $elem528 = new \metastore\WriteEventInfo();
+ $xfer += $elem528->read($input);
+ $this->writeEventInfos []= $elem528;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
default:
$xfer += $input->skip($ftype);
break;
@@ -16638,6 +16672,236 @@ class CommitTxnRequest {
$xfer += $output->writeString($this->replPolicy);
$xfer += $output->writeFieldEnd();
}
+ if ($this->writeEventInfos !== null) {
+ if (!is_array($this->writeEventInfos)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('writeEventInfos', TType::LST, 3);
+ {
+ $output->writeListBegin(TType::STRUCT, count($this->writeEventInfos));
+ {
+ foreach ($this->writeEventInfos as $iter529)
+ {
+ $xfer += $iter529->write($output);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class WriteEventInfo {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $writeId = null;
+ /**
+ * @var string
+ */
+ public $database = null;
+ /**
+ * @var string
+ */
+ public $table = null;
+ /**
+ * @var string
+ */
+ public $files = null;
+ /**
+ * @var string
+ */
+ public $partition = null;
+ /**
+ * @var string
+ */
+ public $tableObj = null;
+ /**
+ * @var string
+ */
+ public $partitionObj = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'writeId',
+ 'type' => TType::I64,
+ ),
+ 2 => array(
+ 'var' => 'database',
+ 'type' => TType::STRING,
+ ),
+ 3 => array(
+ 'var' => 'table',
+ 'type' => TType::STRING,
+ ),
+ 4 => array(
+ 'var' => 'files',
+ 'type' => TType::STRING,
+ ),
+ 5 => array(
+ 'var' => 'partition',
+ 'type' => TType::STRING,
+ ),
+ 6 => array(
+ 'var' => 'tableObj',
+ 'type' => TType::STRING,
+ ),
+ 7 => array(
+ 'var' => 'partitionObj',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['writeId'])) {
+ $this->writeId = $vals['writeId'];
+ }
+ if (isset($vals['database'])) {
+ $this->database = $vals['database'];
+ }
+ if (isset($vals['table'])) {
+ $this->table = $vals['table'];
+ }
+ if (isset($vals['files'])) {
+ $this->files = $vals['files'];
+ }
+ if (isset($vals['partition'])) {
+ $this->partition = $vals['partition'];
+ }
+ if (isset($vals['tableObj'])) {
+ $this->tableObj = $vals['tableObj'];
+ }
+ if (isset($vals['partitionObj'])) {
+ $this->partitionObj = $vals['partitionObj'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'WriteEventInfo';
+ }
+
+ 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->writeId);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->database);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->table);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->files);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 5:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->partition);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 6:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->tableObj);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 7:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->partitionObj);
+ } 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('WriteEventInfo');
+ if ($this->writeId !== null) {
+ $xfer += $output->writeFieldBegin('writeId', TType::I64, 1);
+ $xfer += $output->writeI64($this->writeId);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->database !== null) {
+ $xfer += $output->writeFieldBegin('database', TType::STRING, 2);
+ $xfer += $output->writeString($this->database);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->table !== null) {
+ $xfer += $output->writeFieldBegin('table', TType::STRING, 3);
+ $xfer += $output->writeString($this->table);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->files !== null) {
+ $xfer += $output->writeFieldBegin('files', TType::STRING, 4);
+ $xfer += $output->writeString($this->files);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->partition !== null) {
+ $xfer += $output->writeFieldBegin('partition', TType::STRING, 5);
+ $xfer += $output->writeString($this->partition);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->tableObj !== null) {
+ $xfer += $output->writeFieldBegin('tableObj', TType::STRING, 6);
+ $xfer += $output->writeString($this->tableObj);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->partitionObj !== null) {
+ $xfer += $output->writeFieldBegin('partitionObj', TType::STRING, 7);
+ $xfer += $output->writeString($this->partitionObj);
+ $xfer += $output->writeFieldEnd();
+ }
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
@@ -16785,14 +17049,14 @@ class ReplTblWriteIdStateRequest {
case 6:
if ($ftype == TType::LST) {
$this->partNames = array();
- $_size523 = 0;
- $_etype526 = 0;
- $xfer += $input->readListBegin($_etype526, $_size523);
- for ($_i527 = 0; $_i527 < $_size523; ++$_i527)
+ $_size530 = 0;
+ $_etype533 = 0;
+ $xfer += $input->readListBegin($_etype533, $_size530);
+ for ($_i534 = 0; $_i534 < $_size530; ++$_i534)
{
- $elem528 = null;
- $xfer += $input->readString($elem528);
- $this->partNames []= $elem528;
+ $elem535 = null;
+ $xfer += $input->readString($elem535);
+ $this->partNames []= $elem535;
}
$xfer += $input->readListEnd();
} else {
@@ -16845,9 +17109,9 @@ class ReplTblWriteIdStateRequest {
{
$output->writeListBegin(TType::STRING, count($this->partNames));
{
- foreach ($this->partNames as $iter529)
+ foreach ($this->partNames as $iter536)
{
- $xfer += $output->writeString($iter529);
+ $xfer += $output->writeString($iter536);
}
}
$output->writeListEnd();
@@ -16922,14 +17186,14 @@ class GetValidWriteIdsRequest {
case 1:
if ($ftype == TType::LST) {
$this->fullTableNames = array();
- $_size530 = 0;
- $_etype533 = 0;
- $xfer += $input->readListBegin($_etype533, $_size530);
- for ($_i534 = 0; $_i534 < $_size530; ++$_i534)
+ $_size537 = 0;
+ $_etype540 = 0;
+ $xfer += $input->readListBegin($_etype540, $_size537);
+ for ($_i541 = 0; $_i541 < $_size537; ++$_i541)
{
- $elem535 = null;
- $xfer += $input->readString($elem535);
- $this->fullTableNames []= $elem535;
+ $elem542 = null;
+ $xfer += $input->readString($elem542);
+ $this->fullTableNames []= $elem542;
}
$xfer += $input->readListEnd();
} else {
@@ -16964,9 +17228,9 @@ class GetValidWriteIdsRequest {
{
$output->writeListBegin(TType::STRING, count($this->fullTableNames));
{
- foreach ($this->fullTableNames as $iter536)
+ foreach ($this->fullTableNames as $iter543)
{
- $xfer += $output->writeString($iter536);
+ $xfer += $output->writeString($iter543);
}
}
$output->writeListEnd();
@@ -17093,14 +17357,14 @@ class TableValidWriteIds {
case 3:
if ($ftype == TType::LST) {
$this->invalidWriteIds = array();
- $_size537 = 0;
- $_etype540 = 0;
- $xfer += $input->readListBegin($_etype540, $_size537);
- for ($_i541 = 0; $_i541 < $_size537; ++$_i541)
+ $_size544 = 0;
+ $_etype547 = 0;
+ $xfer += $input->readListBegin($_etype547, $_size544);
+ for ($_i548 = 0; $_i548 < $_size544; ++$_i548)
{
- $elem542 = null;
- $xfer += $input->readI64($elem542);
- $this->invalidWriteIds []= $elem542;
+ $elem549 = null;
+ $xfer += $input->readI64($elem549);
+ $this->invalidWriteIds []= $elem549;
}
$xfer += $input->readListEnd();
} else {
@@ -17152,9 +17416,9 @@ class TableValidWriteIds {
{
$output->writeListBegin(TType::I64, count($this->invalidWriteIds));
{
- foreach ($this->invalidWriteIds as $iter543)
+ foreach ($this->invalidWriteIds as $iter550)
{
- $xfer += $output->writeI64($iter543);
+ $xfer += $output->writeI64($iter550);
}
}
$output->writeListEnd();
@@ -17229,15 +17493,15 @@ class GetValidWriteIdsResponse {
case 1:
if ($ftype == TType::LST) {
$this->tblValidWriteIds = array();
- $_size544 = 0;
- $_etype547 = 0;
- $xfer += $input->readListBegin($_etype547, $_size544);
- for ($_i548 = 0; $_i548 < $_size544; ++$_i548)
+ $_size551 = 0;
+ $_etype554 = 0;
+ $xfer += $input->readListBegin($_etype554, $_size551);
+ for ($_i555 = 0; $_i555 < $_size551; ++$_i555)
{
- $elem549 = null;
- $elem549 = new \metastore\TableValidWriteIds();
- $xfer += $elem549->read($input);
- $this->tblValidWriteIds []= $elem549;
+ $elem556 = null;
+ $elem556 = new \metastore\TableValidWriteIds();
+ $xfer += $elem556->read($input);
+ $this->tblValidWriteIds []= $elem556;
}
$xfer += $input->readListEnd();
} else {
@@ -17265,9 +17529,9 @@ class GetValidWriteIdsResponse {
{
$output->writeListBegin(TType::STRUCT, count($this->tblValidWriteIds));
{
- foreach ($this->tblValidWriteIds as $iter550)
+ foreach ($this->tblValidWriteIds as $iter557)
{
- $xfer += $iter550->write($output);
+ $xfer += $iter557->write($output);
}
}
$output->writeListEnd();
@@ -17394,14 +17658,14 @@ class AllocateTableWriteIdsRequest {
case 3:
if ($ftype == TType::LST) {
$this->txnIds = array();
- $_size551 = 0;
- $_etype554 = 0;
- $xfer += $input->readListBegin($_etype554, $_size551);
- for ($_i555 = 0; $_i555 < $_size551; ++$_i555)
+ $_size558 = 0;
+ $_etype561 = 0;
+ $xfer += $input->readListBegin($_etype561, $_size558);
+ for ($_i562 = 0; $_i562 < $_size558; ++$_i562)
{
- $elem556 = null;
- $xfer += $input->readI64($elem556);
- $this->txnIds []= $elem556;
+ $elem563 = null;
+ $xfer += $input->readI64($elem563);
+ $this->txnIds []= $elem563;
}
$xfer += $input->readListEnd();
} else {
@@ -17418,15 +17682,15 @@ class AllocateTableWriteIdsRequest {
case 5:
if ($ftype == TType::LST) {
$this->srcTxnToWriteIdList = array();
- $_size557 = 0;
- $_etype560 = 0;
- $xfer += $input->readListBegin($_etype560, $_size557);
- for ($_i561 = 0; $_i561 < $_size557; ++$_i561)
+ $_size564 = 0;
+ $_etype567 = 0;
+ $xfer += $input->readListBegin($_etype567, $_size564);
+ for ($_i568 = 0; $_i568 < $_size564; ++$_i568)
{
- $elem562 = null;
- $elem562 = new \metastore\TxnToWriteId();
- $xfer += $elem562->read($input);
- $this->srcTxnToWriteIdList []= $elem562;
+ $elem569 = null;
+ $elem569 = new \metastore\TxnToWriteId();
+ $xfer += $elem569->read($input);
+ $this->srcTxnToWriteIdList []= $elem569;
}
$xfer += $input->readListEnd();
} else {
@@ -17464,9 +17728,9 @@ class AllocateTableWriteIdsRequest {
{
$output->writeListBegin(TType::I64, count($this->txnIds));
{
- foreach ($this->txnIds as $iter563)
+ foreach ($this->txnIds as $iter570)
{
- $xfer += $output->writeI64($iter563);
+ $xfer += $output->writeI64($iter570);
}
}
$output->writeListEnd();
@@ -17486,9 +17750,9 @@ class AllocateTableWriteIdsRequest {
{
$output->writeListBegin(TType::STRUCT, count($this->srcTxnToWriteIdList));
{
- foreach ($this->srcTxnToWriteIdList as $iter564)
+ foreach ($this->srcTxnToWriteIdList as $iter571)
{
- $xfer += $iter564->write($output);
+ $xfer += $iter571->write($output);
}
}
$output->writeListEnd();
@@ -17651,16 +17915,16 @@ class AllocateTableWriteIdsResponse {
case 1:
if ($ftype == TType::LST) {
$this->txnToWriteIds = array();
- $_size565 = 0;
- $_etype568 = 0;
- $xfer += $input->readListBegin($_etype568, $_size565);
- for ($_i569 = 0; $_i569 < $_size565; ++$_i569)
+ $_size572 = 0;
+ $_etype575 = 0;
+ $xfer += $input->readListBegin($_etype575, $_size572);
+ for ($_i576 = 0; $_i576 < $_size572; ++$_i576)
{
- $elem570 = null;
- $elem570 = new \metastore\TxnToWriteId();
- $xfer += $elem570->read($input);
- $this->txnToWriteIds []= $elem570;
- }
+ $elem577 = null;
+ $elem577 = new \metastore\TxnToWriteId();
+ $xfer += $elem577->read($input);
+ $this->txnToWriteIds []= $elem577;
+ }
$xfer += $input->readListEnd();
} else {
$xfer += $input->skip($ftype);
@@ -17687,9 +17951,9 @@ class AllocateTableWriteIdsResponse {
{
$output->writeListBegin(TType::STRUCT, count($this->txnToWriteIds));
{
- foreach ($this->txnToWriteIds as $iter571)
+ foreach ($this->txnToWriteIds as $iter578)
{
- $xfer += $iter571->write($output);
+ $xfer += $iter578->write($output);
}
}
$output->writeListEnd();
@@ -18034,15 +18298,15 @@ class LockRequest {
case 1:
if ($ftype == TType::LST) {
$this->component = array();
- $_size572 = 0;
- $_etype575 = 0;
- $xfer += $input->readListBegin($_etype575, $_size572);
- for ($_i576 = 0; $_i576 < $_size572; ++$_i576)
+ $_size579 = 0;
+ $_etype582 = 0;
+ $xfer += $input->readListBegin($_etype582, $_size579);
+ for ($_i583 = 0; $_i583 < $_size579; ++$_i583)
{
- $elem577 = null;
- $elem577 = new \metastore\LockComponent();
- $xfer += $elem577->read($input);
- $this->component []= $elem577;
+ $elem584 = null;
+ $elem584 = new \metastore\LockComponent();
+ $xfer += $elem584->read($input);
+ $this->component []= $elem584;
}
$xfer += $input->readListEnd();
} else {
@@ -18098,9 +18362,9 @@ class LockRequest {
{
$output->writeListBegin(TType::STRUCT, count($this->component));
{
- foreach ($this->component as $iter578)
+ foreach ($this->component as $iter585)
{
- $xfer += $iter578->write($output);
+ $xfer += $iter585->write($output);
}
}
$output->writeListEnd();
@@ -19043,15 +19307,15 @@ class ShowLocksResponse {
case 1:
if ($ftype == TType::LST) {
$this->locks = array();
- $_size579 = 0;
- $_etype582 = 0;
- $xfer += $input->readListBegin($_etype582, $_size579);
- for ($_i583 = 0; $_i583 < $_size579; ++$_i583)
+ $_size586 = 0;
+ $_etype589 = 0;
+ $xfer += $input->readListBegin($_etype589, $_size586);
+ for ($_i590 = 0; $_i590 < $_size586; ++$_i590)
{
- $elem584 = null;
- $elem584 = new \metastore\ShowLocksResponseElement();
- $xfer += $elem584->read($input);
- $this->locks []= $elem584;
+ $elem591 = null;
+ $elem591 = new \metastore\ShowLocksResponseElement();
+ $xfer += $elem591->read($input);
+ $this->locks []= $elem591;
}
$xfer += $input->readListEnd();
} else {
@@ -19079,9 +19343,9 @@ class ShowLocksResponse {
{
$output->writeListBegin(TType::STRUCT, count($this->locks));
{
- foreach ($this->locks as $iter585)
+ foreach ($this->locks as $iter592)
{
- $xfer += $iter585->write($output);
+ $xfer += $iter592->write($output);
}
}
$output->writeListEnd();
@@ -19356,17 +19620,17 @@ class HeartbeatTxnRangeResponse {
case 1:
if ($ftype == TType::SET) {
$this->aborted = array();
- $_size586 = 0;
- $_etype589 = 0;
- $xfer += $input->readSetBegin($_etype589, $_size586);
- for ($_i590 = 0; $_i590 < $_size586; ++$_i590)
+ $_size593 = 0;
+ $_etype596 = 0;
+ $xfer += $input->readSetBegin($_etype596, $_size593);
+ for ($_i597 = 0; $_i597 < $_size593; ++$_i597)
{
- $elem591 = null;
- $xfer += $input->readI64($elem591);
- if (is_scalar($elem591)) {
- $this->aborted[$elem591] = true;
+ $elem598 = null;
+ $xfer += $input->readI64($elem598);
+ if (is_scalar($elem598)) {
+ $this->aborted[$elem598] = true;
} else {
- $this->aborted []= $elem591;
+ $this->aborted []= $elem598;
}
}
$xfer += $input->readSetEnd();
@@ -19377,17 +19641,17 @@ class HeartbeatTxnRangeResponse {
case 2:
if ($ftype == TType::SET) {
$this->nosuch = array();
- $_size592 = 0;
- $_etype595 = 0;
- $xfer += $input->readSetBegin($_etype595, $_size592);
- for ($_i596 = 0; $_i596 < $_size592; ++$_i596)
+ $_size599 = 0;
+ $_etype602 = 0;
+ $xfer += $input->readSetBegin($_etype602, $_size599);
+ for ($_i603 = 0; $_i603 < $_size599; ++$_i603)
{
- $elem597 = null;
- $xfer += $input->readI64($elem597);
- if (is_scalar($elem597)) {
- $this->nosuch[$elem597] = true;
+ $elem604 = null;
+ $xfer += $input->readI64($elem604);
+ if (is_scalar($elem604)) {
+ $this->nosuch[$elem604] = true;
} else {
- $this->nosuch []= $elem597;
+ $this->nosuch []= $elem604;
}
}
$xfer += $input->readSetEnd();
@@ -19416,12 +19680,12 @@ class HeartbeatTxnRangeResponse {
{
$output->writeSetBegin(TType::I64, count($this->aborted));
{
- foreach ($this->aborted as $iter598 => $iter599)
+ foreach ($this->aborted as $iter605 => $iter606)
{
- if (is_scalar($iter599)) {
- $xfer += $output->writeI64($iter598);
+ if (is_scalar($iter606)) {
+ $xfer += $output->writeI64($iter605);
} else {
- $xfer += $output->writeI64($iter599);
+ $xfer += $output->writeI64($iter606);
}
}
}
@@ -19437,12 +19701,12 @@ class HeartbeatTxnRangeResponse {
{
$output->writeSetBegin(TType::I64, count($this->nosuch));
{
- foreach ($this->nosuch as $iter600 => $iter601)
+ foreach ($this->nosuch as $iter607 => $iter608)
{
- if (is_scalar($iter601)) {
- $xfer += $output->writeI64($iter600);
+ if (is_scalar($iter608)) {
+ $xfer += $output->writeI64($iter607);
} else {
- $xfer += $output->writeI64($iter601);
+ $xfer += $output->writeI64($iter608);
}
}
}
@@ -19601,17 +19865,17 @@ class CompactionRequest {
case 6:
if ($ftype == TType::MAP) {
$this->properties = array();
- $_size602 = 0;
- $_ktype603 = 0;
- $_vtype604 = 0;
- $xfer += $input->readMapBegin($_ktype603, $_vtype604, $_size602);
- for ($_i606 = 0; $_i606 < $_size602; ++$_i606)
+ $_size609 = 0;
+ $_ktype610 = 0;
+ $_vtype611 = 0;
+ $xfer += $input->readMapBegin($_ktype610, $_vtype611, $_size609);
+ for ($_i613 = 0; $_i613 < $_size609; ++$_i613)
{
- $key607 = '';
- $val608 = '';
- $xfer += $input->readString($key607);
- $xfer += $input->readString($val608);
- $this->properties[$key607] = $val608;
+ $key614 = '';
+ $val615 = '';
+ $xfer += $input->readString($key614);
+ $xfer += $input->readString($val615);
+ $this->properties[$key614] = $val615;
}
$xfer += $input->readMapEnd();
} else {
@@ -19664,10 +19928,10 @@ class CompactionRequest {
{
$output->writeMapBegin(TType::STRING, TType::STRING, count($this->properties));
{
- foreach ($this->properties as $kiter609 => $viter610)
+ foreach ($this->properties as $kiter616 => $viter617)
{
- $xfer += $output->writeString($kiter609);
- $xfer += $output->writeString($viter610);
+ $xfer += $output->writeString($kiter616);
+ $xfer += $output->writeString($viter617);
}
}
$output->writeMapEnd();
@@ -20254,15 +20518,15 @@ class ShowCompactResponse {
case 1:
if ($ftype == TType::LST) {
$this->compacts = array();
- $_size611 = 0;
- $_etype614 = 0;
- $xfer += $input->readListBegin($_etype614, $_size611);
- for ($_i615 = 0; $_i615 < $_size611; ++$_i615)
+ $_size618 = 0;
+ $_etype621 = 0;
+ $xfer += $input->readListBegin($_etype621, $_size618);
+ for ($_i622 = 0; $_i622 < $_size618; ++$_i622)
{
- $elem616 = null;
- $elem616 = new \metastore\ShowCompactResponseElement();
- $xfer += $elem616->read($input);
- $this->compacts []= $elem616;
+ $elem623 = null;
+ $elem623 = new \metastore\ShowCompactResponseElement();
+ $xfer += $elem623->read($input);
+ $this->compacts []= $elem623;
}
$xfer += $input->readListEnd();
} else {
@@ -20290,9 +20554,9 @@ class ShowCompactResponse {
{
$output->writeListBegin(TType::STRUCT, count($this->compacts));
{
- foreach ($this->compacts as $iter617)
+ foreach ($this->compacts as $iter624)
{
- $xfer += $iter617->write($output);
+ $xfer += $iter624->write($output);
}
}
$output->writeListEnd();
@@ -20439,14 +20703,14 @@ class AddDynamicPartitions {
case 5:
if ($ftype == TType::LST) {
$this->partitionnames = array();
- $_size618 = 0;
- $_etype621 = 0;
- $xfer += $input->readListBegin($_etype621, $_size618);
- for ($_i622 = 0; $_i622 < $_size618; ++$_i622)
+ $_size625 = 0;
+ $_etype628 = 0;
+ $xfer += $input->readListBegin($_etype628, $_size625);
+ for ($_i629 = 0; $_i629 < $_size625; ++$_i629)
{
- $elem623 = null;
- $xfer += $input->readString($elem623);
- $this->partitionnames []= $elem623;
+ $elem630 = null;
+ $xfer += $input->readString($elem630);
+ $this->partitionnames []= $elem630;
}
$xfer += $input->readListEnd();
} else {
@@ -20501,9 +20765,9 @@ class AddDynamicPartitions {
{
$output->writeListBegin(TType::STRING, count($this->partitionnames));
{
- foreach ($this->partitionnames as $iter624)
+ foreach ($this->partitionnames as $iter631)
{
- $xfer += $output->writeString($iter624);
+ $xfer += $output->writeString($iter631);
}
}
$output->writeListEnd();
@@ -20827,17 +21091,17 @@ class CreationMetadata {
case 4:
if ($ftype == TType::SET) {
$this->tablesUsed = array();
- $_size625 = 0;
- $_etype628 = 0;
- $xfer += $input->readSetBegin($_etype628, $_size625);
- for ($_i629 = 0; $_i629 < $_size625; ++$_i629)
+ $_size632 = 0;
+ $_etype635 = 0;
+ $xfer += $input->readSetBegin($_etype635, $_size632);
+ for ($_i636 = 0; $_i636 < $_size632; ++$_i636)
{
- $elem630 = null;
- $xfer += $input->readString($elem630);
- if (is_scalar($elem630)) {
- $this->tablesUsed[$elem630] = true;
+ $elem637 = null;
+ $xfer += $input->readString($elem637);
+ if (is_scalar($elem637)) {
+ $this->tablesUsed[$elem637] = true;
} else {
- $this->tablesUsed []= $elem630;
+ $this->tablesUsed []= $elem637;
}
}
$xfer += $input->readSetEnd();
@@ -20888,12 +21152,12 @@ class CreationMetadata {
{
$output->writeSetBegin(TType::STRING, count($this->tablesUsed));
{
- foreach ($this->tablesUsed as $iter631 => $iter632)
+ foreach ($this->tablesUsed as $iter638 => $iter639)
{
- if (is_scalar($iter632)) {
- $xfer += $output->writeString($iter631);
+ if (is_scalar($iter639)) {
+ $xfer += $output->writeString($iter638);
} else {
- $xfer += $output->writeString($iter632);
+ $xfer += $output->writeString($iter639);
}
}
}
@@ -21298,15 +21562,15 @@ class NotificationEventResponse {
case 1:
if ($ftype == TType::LST) {
$this->events = array();
- $_size633 = 0;
- $_etype636 = 0;
- $xfer += $input->readListBegin($_etype636, $_size633);
- for ($_i637 = 0; $_i637 < $_size633; ++$_i637)
+ $_size640 = 0;
+ $_etype643 = 0;
+ $xfer += $input->readListBegin($_etype643, $_size640);
+ for ($_i644 = 0; $_i644 < $_size640; ++$_i644)
{
- $elem638 = null;
- $elem638 = new \metastore\NotificationEvent();
- $xfer += $elem638->read($input);
- $this->events []= $elem638;
+ $elem645 = null;
+ $elem645 = new \metastore\NotificationEvent();
+ $xfer += $elem645->read($input);
+ $this->events []= $elem645;
}
$xfer += $input->readListEnd();
} else {
@@ -21334,9 +21598,9 @@ class NotificationEventResponse {
{
$output->writeListBegin(TType::STRUCT, count($this->events));
{
- foreach ($this->events as $iter639)
+ foreach ($this->events as $iter646)
{
- $xfer += $iter639->write($output);
+ $xfer += $iter646->write($output);
}
}
$output->writeListEnd();
@@ -21636,6 +21900,10 @@ class InsertEventRequestData {
* @var string[]
*/
public $filesAddedChecksum = null;
+ /**
+ * @var string[]
+ */
+ public $subDirectoryList = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
@@ -21660,6 +21928,14 @@ class InsertEventRequestData {
'type' => TType::STRING,
),
),
+ 4 => array(
+ 'var' => 'subDirectoryList',
+ 'type' => TType::LST,
+ 'etype' => TType::STRING,
+ 'elem' => array(
+ 'type' => TType::STRING,
+ ),
+ ),
);
}
if (is_array($vals)) {
@@ -21672,6 +21948,9 @@ class InsertEventRequestData {
if (isset($vals['filesAddedChecksum'])) {
$this->filesAddedChecksum = $vals['filesAddedChecksum'];
}
+ if (isset($vals['subDirectoryList'])) {
+ $this->subDirectoryList = $vals['subDirectoryList'];
+ }
}
}
@@ -21704,14 +21983,14 @@ class InsertEventRequestData {
case 2:
if ($ftype == TType::LST) {
$this->filesAdded = array();
- $_size640 = 0;
- $_etype643 = 0;
- $xfer += $input->readListBegin($_etype643, $_size640);
- for ($_i644 = 0; $_i644 < $_size640; ++$_i644)
+ $_size647 = 0;
+ $_etype650 = 0;
+ $xfer += $input->readListBegin($_etype650, $_size647);
+ for ($_i651 = 0; $_i651 < $_size647; ++$_i651)
{
- $elem645 = null;
- $xfer += $input->readString($elem645);
- $this->filesAdded []= $elem645;
+ $elem652 = null;
+ $xfer += $input->readString($elem652);
+ $this->filesAdded []= $elem652;
}
$xfer += $input->readListEnd();
} else {
@@ -21721,14 +22000,31 @@ class InsertEventRequestData {
case 3:
if ($ftype == TType::LST) {
$this->filesAddedChecksum = array();
- $_size646 = 0;
- $_etype649 = 0;
- $xfer += $input->readListBegin($_etype649, $_size646);
- for ($_i650 = 0; $_i650 < $_size646; ++$_i650)
+ $_size653 = 0;
+ $_etype656 = 0;
+ $xfer += $input->readListBegin($_etype656, $_size653);
+ for ($_i657 = 0; $_i657 < $_size653; ++$_i657)
+ {
+ $elem658 = null;
+ $xfer += $input->readString($elem658);
+ $this->filesAddedChecksum []= $elem658;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::LST) {
+ $this->subDirectoryList = array();
+ $_size659 = 0;
+ $_etype662 = 0;
+ $xfer += $input->readListBegin($_etype662, $_size659);
+ for ($_i663 = 0; $_i663 < $_size659; ++$_i663)
{
- $elem651 = null;
- $xfer += $input->readString($elem651);
- $this->filesAddedChecksum []= $elem651;
+ $elem664 = null;
+ $xfer += $input->readString($elem664);
+ $this->subDirectoryList []= $elem664;
}
$xfer += $input->readListEnd();
} else {
@@ -21761,9 +22057,9 @@ class InsertEventRequestData {
{
$output->writeListBegin(TType::STRING, count($this->filesAdded));
{
- foreach ($this->filesAdded as $iter652)
+ foreach ($this->filesAdded as $iter665)
{
- $xfer += $output->writeString($iter652);
+ $xfer += $output->writeString($iter665);
}
}
$output->writeListEnd();
@@ -21778,9 +22074,26 @@ class InsertEventRequestData {
{
$output->writeListBegin(TType::STRING, count($this->filesAddedChecksum));
{
- foreach ($this->filesAddedChecksum as $iter653)
+ foreach ($this->filesAddedChecksum as $iter666)
+ {
+ $xfer += $output->writeString($iter666);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->subDirectoryList !== null) {
+ if (!is_array($this->subDirectoryList)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('subDirectoryList', TType::LST, 4);
+ {
+ $output->writeListBegin(TType::STRING, count($this->subDirectoryList));
+ {
+ foreach ($this->subDirectoryList as $iter667)
{
- $xfer += $output->writeString($iter653);
+ $xfer += $output->writeString($iter667);
}
}
$output->writeListEnd();
@@ -21794,33 +22107,320 @@ class InsertEventRequestData {
}
-class FireEventRequestData {
+class FireEventRequestData {
+ static $_TSPEC;
+
+ /**
+ * @var \metastore\InsertEventRequestData
+ */
+ public $insertData = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'insertData',
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\InsertEventRequestData',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['insertData'])) {
+ $this->insertData = $vals['insertData'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'FireEventRequestData';
+ }
+
+ 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::STRUCT) {
+ $this->insertData = new \metastore\InsertEventRequestData();
+ $xfer += $this->insertData->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('FireEventRequestData');
+ if ($this->insertData !== null) {
+ if (!is_object($this->insertData)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('insertData', TType::STRUCT, 1);
+ $xfer += $this->insertData->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class FireEventRequest {
+ static $_TSPEC;
+
+ /**
+ * @var bool
+ */
+ public $successful = null;
+ /**
+ * @var \metastore\FireEventRequestData
+ */
+ public $data = null;
+ /**
+ * @var string
+ */
+ public $dbName = null;
+ /**
+ * @var string
+ */
+ public $tableName = null;
+ /**
+ * @var string[]
+ */
+ public $partitionVals = null;
+ /**
+ * @var string
+ */
+ public $catName = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'successful',
+ 'type' => TType::BOOL,
+ ),
+ 2 => array(
+ 'var' => 'data',
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\FireEventRequestData',
+ ),
+ 3 => array(
+ 'var' => 'dbName',
+ 'type' => TType::STRING,
+ ),
+ 4 => array(
+ 'var' => 'tableName',
+ 'type' => TType::STRING,
+ ),
+ 5 => array(
+ 'var' => 'partitionVals',
+ 'type' => TType::LST,
+ 'etype' => TType::STRING,
+ 'elem' => array(
+ 'type' => TType::STRING,
+ ),
+ ),
+ 6 => array(
+ 'var' => 'catName',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['successful'])) {
+ $this->successful = $vals['successful'];
+ }
+ if (isset($vals['data'])) {
+ $this->data = $vals['data'];
+ }
+ if (isset($vals['dbName'])) {
+ $this->dbName = $vals['dbName'];
+ }
+ if (isset($vals['tableName'])) {
+ $this->tableName = $vals['tableName'];
+ }
+ if (isset($vals['partitionVals'])) {
+ $this->partitionVals = $vals['partitionVals'];
+ }
+ if (isset($vals['catName'])) {
+ $this->catName = $vals['catName'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'FireEventRequest';
+ }
+
+ 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::BOOL) {
+ $xfer += $input->readBool($this->successful);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->data = new \metastore\FireEventRequestData();
+ $xfer += $this->data->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->dbName);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->tableName);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 5:
+ if ($ftype == TType::LST) {
+ $this->partitionVals = array();
+ $_size668 = 0;
+ $_etype671 = 0;
+ $xfer += $input->readListBegin($_etype671, $_size668);
+ for ($_i672 = 0; $_i672 < $_size668; ++$_i672)
+ {
+ $elem673 = null;
+ $xfer += $input->readString($elem673);
+ $this->partitionVals []= $elem673;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 6:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->catName);
+ } 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('FireEventRequest');
+ if ($this->successful !== null) {
+ $xfer += $output->writeFieldBegin('successful', TType::BOOL, 1);
+ $xfer += $output->writeBool($this->successful);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->data !== null) {
+ if (!is_object($this->data)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('data', TType::STRUCT, 2);
+ $xfer += $this->data->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->dbName !== null) {
+ $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, 4);
+ $xfer += $output->writeString($this->tableName);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->partitionVals !== null) {
+ if (!is_array($this->partitionVals)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('partitionVals', TType::LST, 5);
+ {
+ $output->writeListBegin(TType::STRING, count($this->partitionVals));
+ {
+ foreach ($this->partitionVals as $iter674)
+ {
+ $xfer += $output->writeString($iter674);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->catName !== null) {
+ $xfer += $output->writeFieldBegin('catName', TType::STRING, 6);
+ $xfer += $output->writeString($this->catName);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class FireEventResponse {
static $_TSPEC;
- /**
- * @var \metastore\InsertEventRequestData
- */
- public $insertData = null;
- public function __construct($vals=null) {
+ public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
- 1 => array(
- 'var' => 'insertData',
- 'type' => TType::STRUCT,
- 'class' => '\metastore\InsertEventRequestData',
- ),
);
}
- if (is_array($vals)) {
- if (isset($vals['insertData'])) {
- $this->insertData = $vals['insertData'];
- }
- }
}
public function getName() {
- return 'FireEventRequestData';
+ return 'FireEventResponse';
}
public function read($input)
@@ -21838,14 +22438,6 @@ class FireEventRequestData {
}
switch ($fid)
{
- case 1:
- if ($ftype == TType::STRUCT) {
- $this->insertData = new \metastore\InsertEventRequestData();
- $xfer += $this->insertData->read($input);
- } else {
- $xfer += $input->skip($ftype);
- }
- break;
default:
$xfer += $input->skip($ftype);
break;
@@ -21858,15 +22450,7 @@ class FireEventRequestData {
public function write($output) {
$xfer = 0;
- $xfer += $output->writeStructBegin('FireEventRequestData');
- if ($this->insertData !== null) {
- if (!is_object($this->insertData)) {
- throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
- }
- $xfer += $output->writeFieldBegin('insertData', TType::STRUCT, 1);
- $xfer += $this->insertData->write($output);
- $xfer += $output->writeFieldEnd();
- }
+ $xfer += $output->writeStructBegin('FireEventResponse');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
@@ -21874,55 +22458,59 @@ class FireEventRequestData {
}
-class FireEventRequest {
+class WriteNotificationLogRequest {
static $_TSPEC;
/**
- * @var bool
+ * @var int
*/
- public $successful = null;
+ public $txnId = null;
/**
- * @var \metastore\FireEventRequestData
+ * @var int
*/
- public $data = null;
+ public $writeId = null;
/**
* @var string
*/
- public $dbName = null;
+ public $db = null;
/**
* @var string
*/
- public $tableName = null;
+ public $table = null;
/**
- * @var string[]
+ * @var \metastore\InsertEventRequestData
*/
- public $partitionVals = null;
+ public $fileInfo = null;
/**
- * @var string
+ * @var string[]
*/
- public $catName = null;
+ public $partitionVals = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
- 'var' => 'successful',
- 'type' => TType::BOOL,
+ 'var' => 'txnId',
+ 'type' => TType::I64,
),
2 => array(
- 'var' => 'data',
- 'type' => TType::STRUCT,
- 'class' => '\metastore\FireEventRequestData',
+ 'var' => 'writeId',
+ 'type' => TType::I64,
),
3 => array(
- 'var' => 'dbName',
+ 'var' => 'db',
'type' => TType::STRING,
),
4 => array(
- 'var' => 'tableName',
+ 'var' => 'table',
'type' => TType::STRING,
),
5 => array(
+ 'var' => 'fileInfo',
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\InsertEventRequestData',
+ ),
+ 6 => array(
'var' => 'partitionVals',
'type' => TType::LST,
'etype' => TType::STRING,
@@ -21930,36 +22518,32 @@ class FireEventRequest {
'type' => TType::STRING,
),
),
- 6 => array(
- 'var' => 'catName',
- 'type' => TType::STRING,
- ),
);
}
if (is_array($vals)) {
- if (isset($vals['successful'])) {
- $this->successful = $vals['successful'];
+ if (isset($vals['txnId'])) {
+ $this->txnId = $vals['txnId'];
}
- if (isset($vals['data'])) {
- $this->data = $vals['data'];
+ if (isset($vals['writeId'])) {
+ $this->writeId = $vals['writeId'];
}
- if (isset($vals['dbName'])) {
- $this->dbName = $vals['dbName'];
+ if (isset($vals['db'])) {
+ $this->db = $vals['db'];
}
- if (isset($vals['tableName'])) {
- $this->tableName = $vals['tableName'];
+ if (isset($vals['table'])) {
+ $this->table = $vals['table'];
+ }
+ if (isset($vals['fileInfo'])) {
+ $this->fileInfo = $vals['fileInfo'];
}
if (isset($vals['partitionVals'])) {
$this->partitionVals = $vals['partitionVals'];
}
- if (isset($vals['catName'])) {
- $this->catName = $vals['catName'];
- }
}
}
public function getName() {
- return 'FireEventRequest';
+ return 'WriteNotificationLogRequest';
}
public function read($input)
@@ -21978,54 +22562,54 @@ class FireEventRequest {
switch ($fid)
{
case 1:
- if ($ftype == TType::BOOL) {
- $xfer += $input->readBool($this->successful);
+ if ($ftype == TType::I64) {
+ $xfer += $input->readI64($this->txnId);
} else {
$xfer += $input->skip($ftype);
}
break;
case 2:
- if ($ftype == TType::STRUCT) {
- $this->data = new \metastore\FireEventRequestData();
- $xfer += $this->data->read($input);
+ 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);
+ $xfer += $input->readString($this->db);
} else {
$xfer += $input->skip($ftype);
}
break;
case 4:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->tableName);
+ $xfer += $input->readString($this->table);
} else {
$xfer += $input->skip($ftype);
}
break;
case 5:
- if ($ftype == TType::LST) {
- $this->partitionVals = array();
- $_size654 = 0;
- $_etype657 = 0;
- $xfer += $input->readListBegin($_etype657, $_size654);
- for ($_i658 = 0; $_i658 < $_size654; ++$_i658)
- {
- $elem659 = null;
- $xfer += $input->readString($elem659);
- $this->partitionVals []= $elem659;
- }
- $xfer += $input->readListEnd();
+ if ($ftype == TType::STRUCT) {
+ $this->fileInfo = new \metastore\InsertEventRequestData();
+ $xfer += $this->fileInfo->read($input);
} else {
$xfer += $input->skip($ftype);
}
break;
case 6:
- if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->catName);
+ if ($ftype == TType::LST) {
+ $this->partitionVals = array();
+ $_size675 = 0;
+ $_etype678 = 0;
+ $xfer += $input->readListBegin($_etype678, $_size675);
+ for ($_i679 = 0; $_i679 < $_size675; ++$_i679)
+ {
+ $elem680 = null;
+ $xfer += $input->readString($elem680);
+ $this->partitionVals []= $elem680;
+ }
+ $xfer += $input->readListEnd();
} else {
$xfer += $input->skip($ftype);
}
@@ -22042,52 +22626,52 @@ class FireEventRequest {
public function write($output) {
$xfer = 0;
- $xfer += $output->writeStructBegin('FireEventRequest');
- if ($this->successful !== null) {
- $xfer += $output->writeFieldBegin('successful', TType::BOOL, 1);
- $xfer += $output->writeBool($this->successful);
+ $xfer += $output->writeStructBegin('WriteNotificationLogRequest');
+ if ($this->txnId !== null) {
+ $xfer += $output->writeFieldBegin('txnId', TType::I64, 1);
+ $xfer += $output->writeI64($this->txnId);
$xfer += $output->writeFieldEnd();
}
- if ($this->data !== null) {
- if (!is_object($this->data)) {
- throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
- }
- $xfer += $output->writeFieldBegin('data', TType::STRUCT, 2);
- $xfer += $this->data->write($output);
+ 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, 3);
- $xfer += $output->writeString($this->dbName);
+ if ($this->db !== null) {
+ $xfer += $output->writeFieldBegin('db', TType::STRING, 3);
+ $xfer += $output->writeString($this->db);
$xfer += $output->writeFieldEnd();
}
- if ($this->tableName !== null) {
- $xfer += $output->writeFieldBegin('tableName', TType::STRING, 4);
- $xfer += $output->writeString($this->tableName);
+ if ($this->table !== null) {
+ $xfer += $output->writeFieldBegin('table', TType::STRING, 4);
+ $xfer += $output->writeString($this->table);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->fileInfo !== null) {
+ if (!is_object($this->fileInfo)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('fileInfo', TType::STRUCT, 5);
+ $xfer += $this->fileInfo->write($output);
$xfer += $output->writeFieldEnd();
}
if ($this->partitionVals !== null) {
if (!is_array($this->partitionVals)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
- $xfer += $output->writeFieldBegin('partitionVals', TType::LST, 5);
+ $xfer += $output->writeFieldBegin('partitionVals', TType::LST, 6);
{
$output->writeListBegin(TType::STRING, count($this->partitionVals));
{
- foreach ($this->partitionVals as $iter660)
+ foreach ($this->partitionVals as $iter681)
{
- $xfer += $output->writeString($iter660);
+ $xfer += $output->writeString($iter681);
}
}
$output->writeListEnd();
}
$xfer += $output->writeFieldEnd();
}
- if ($this->catName !== null) {
- $xfer += $output->writeFieldBegin('catName', TType::STRING, 6);
- $xfer += $output->writeString($this->catName);
- $xfer += $output->writeFieldEnd();
- }
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
@@ -22095,7 +22679,7 @@ class FireEventRequest {
}
-class FireEventResponse {
+class WriteNotificationLogResponse {
static $_TSPEC;
@@ -22107,7 +22691,7 @@ class FireEventResponse {
}
public function getName() {
- return 'FireEventResponse';
+ return 'WriteNotificationLogResponse';
}
public function read($input)
@@ -22137,7 +22721,7 @@ class FireEventResponse {
public function write($output) {
$xfer = 0;
- $xfer += $output->writeStructBegin('FireEventResponse');
+ $xfer += $output->writeStructBegin('WriteNotificationLogResponse');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
@@ -22309,18 +22893,18 @@ class GetFileMetadataByExprResult {
case 1:
if ($ftype == TType::MAP) {
$this->metadata = array();
- $_size661 = 0;
- $_ktype662 = 0;
- $_vtype663 = 0;
- $xfer += $input->readMapBegin($_ktype662, $_vtype663, $_size661);
- for ($_i665 = 0; $_i665 < $_size661; ++$_i665)
+ $_size682 = 0;
+ $_ktype683 = 0;
+ $_vtype684 = 0;
+ $xfer += $input->readMapBegin($_ktype683, $_vtype684, $_size682);
+ for ($_i686 = 0; $_i686 < $_size682; ++$_i686)
{
- $key666 = 0;
- $val667 = new \metastore\MetadataPpdResult();
- $xfer += $input->readI64($key666);
- $val667 = new \metastore\MetadataPpdResult();
- $xfer += $val667->read($input);
- $this->metadata[$key666] = $val667;
+ $key687 = 0;
+ $val688 = new \metastore\MetadataPpdResult();
+ $xfer += $input->readI64($key687);
+ $val688 = new \metastore\MetadataPpdResult();
+ $xfer += $val688->read($input);
+ $this->metadata[$key687] = $val688;
}
$xfer += $input->readMapEnd();
} else {
@@ -22355,10 +22939,10 @@ class GetFileMetadataByExprResult {
{
$output->writeMapBegin(TType::I64, TType::STRUCT, count($this->metadata));
{
- foreach ($this->metadata as $kiter668 => $viter669)
+ foreach ($this->metadata as $kiter689 => $viter690)
{
- $xfer += $output->writeI64($kiter668);
- $xfer += $viter669->write($output);
+ $xfer += $output->writeI64($kiter689);
+ $xfer += $viter690->write($output);
}
}
$output->writeMapEnd();
@@ -22460,14 +23044,14 @@ class GetFileMetadataByExprRequest {
case 1:
if ($ftype == TType::LST) {
$this->fileIds = array();
- $_size670 = 0;
- $_etype673 = 0;
- $xfer += $input->readListBegin($_etype673, $_size670);
- for ($_i674 = 0; $_i674 < $_size670; ++$_i674)
+ $_size691 = 0;
+ $_etype694 = 0;
+ $xfer += $input->readListBegin($_etype694, $_size691);
+ for ($_i695 = 0; $_i695 < $_size691; ++$_i695)
{
- $elem675 = null;
- $xfer += $input->readI64($elem675);
- $this->fileIds []= $elem675;
+ $elem696 = null;
+ $xfer += $input->readI64($elem696);
+ $this->fileIds []= $elem696;
}
$xfer += $input->readListEnd();
} else {
@@ -22516,9 +23100,9 @@ class GetFileMetadataByExprRequest {
{
$output->writeListBegin(TType::I64, count($this->fileIds));
{
- foreach ($this->fileIds as $iter676)
+ foreach ($this->fileIds as $iter697)
{
- $xfer += $output->writeI64($iter676);
+ $xfer += $output->writeI64($iter697);
}
}
$output->writeListEnd();
@@ -22612,17 +23196,17 @@ class GetFileMetadataResult {
case 1:
if ($ftype == TType::MAP) {
$this->metadata = array();
- $_size677 = 0;
- $_ktype678 = 0;
- $_vtype679 = 0;
- $xfer += $input->readMapBegin($_ktype678, $_vtype679, $_size677);
- for ($_i681 = 0; $_i681 < $_size677; ++$_i681)
+ $_size698 = 0;
+ $_ktype699 = 0;
+ $_vtype700 = 0;
+ $xfer += $input->readMapBegin($_ktype699, $_vtype700, $_size698);
+ for ($_i702 = 0; $_i702 < $_size698; ++$_i702)
{
- $key682 = 0;
- $val683 = '';
- $xfer += $input->readI64($key682);
- $xfer += $input->readString($val683);
- $this->metadata[$key682] = $val683;
+ $key703 = 0;
+ $val704 = '';
+ $xfer += $input->readI64($key703);
+ $xfer += $input->readString($val704);
+ $this->metadata[$key703] = $val704;
}
$xfer += $input->readMapEnd();
} else {
@@ -22657,10 +23241,10 @@ class GetFileMetadataResult {
{
$output->writeMapBegin(TType::I64, TType::STRING, count($this->metadata));
{
- foreach ($this->metadata as $kiter684 => $viter685)
+ foreach ($this->metadata as $kiter705 => $viter706)
{
- $xfer += $output->writeI64($kiter684);
- $xfer += $output->writeString($viter685);
+ $xfer += $output->writeI64($kiter705);
+ $xfer += $output->writeString($viter706);
}
}
$output->writeMapEnd();
@@ -22729,14 +23313,14 @@ class GetFileMetadataRequest {
case 1:
if ($ftype == TType::LST) {
$this->fileIds = array();
- $_size686 = 0;
- $_etype689 = 0;
- $xfer += $input->readListBegin($_etype689, $_size686);
- for ($_i690 = 0; $_i690 < $_size686; ++$_i690)
+ $_size707 = 0;
+ $_etype710 = 0;
+ $xfer += $input->readListBegin($_etype710, $_size707);
+ for ($_i711 = 0; $_i711 < $_size707; ++$_i711)
{
- $elem691 = null;
- $xfer += $input->readI64($elem691);
- $this->fileIds []= $elem691;
+ $elem712 = null;
+ $xfer += $input->readI64($elem712);
+ $this->fileIds []= $elem712;
}
$xfer += $input->readListEnd();
} else {
@@ -22764,9 +23348,9 @@ class GetFileMetadataRequest {
{
$output->writeListBegin(TType::I64, count($this->fileIds));
{
- foreach ($this->fileIds as $iter692)
+ foreach ($this->fileIds as $iter713)
{
- $xfer += $output->writeI64($iter692);
+ $xfer += $output->writeI64($iter713);
}
}
$output->writeListEnd();
@@ -22906,14 +23490,14 @@ class PutFileMetadataRequest {
case 1:
if ($ftype == TType::LST) {
$this->fileIds = array();
- $_size693 = 0;
- $_etype696 = 0;
- $xfer += $input->readListBegin($_etype696, $_size693);
- for ($_i697 = 0; $_i697 < $_size693; ++$_i697)
+ $_size714 = 0;
+ $_etype717 = 0;
+ $xfer += $input->readListBegin($_etype717, $_size714);
+ for ($_i718 = 0; $_i718 < $_size714; ++$_i718)
{
- $elem698 = null;
- $xfer += $input->readI64($elem698);
- $this->fileIds []= $elem698;
+ $elem719 = null;
+ $xfer += $input->readI64($elem719);
+ $this->fileIds []= $elem719;
}
$xfer += $input->readListEnd();
} else {
@@ -22923,14 +23507,14 @@ class PutFileMetadataRequest {
case 2:
if ($ftype == TType::LST) {
$this->metadata = array();
- $_size699 = 0;
- $_etype702 = 0;
- $xfer += $input->readListBegin($_etype702, $_size699);
- for ($_i703 = 0; $_i703 < $_size699; ++$_i703)
+ $_size720 = 0;
+ $_etype723 = 0;
+ $xfer += $input->readListBegin($_etype723, $_size720);
+ for ($_i724 = 0; $_i724 < $_size720; ++$_i724)
{
- $elem704 = null;
- $xfer += $input->readString($elem704);
- $this->metadata []= $elem704;
+ $elem725 = null;
+ $xfer += $input->readString($elem725);
+ $this->metadata []= $elem725;
}
$xfer += $input->readListEnd();
} else {
@@ -22965,9 +23549,9 @@ class PutFileMetadataRequest {
{
$output->writeListBegin(TType::I64, count($this->fileIds));
{
- foreach ($this->fileIds as $iter705)
+ foreach ($this->fileIds as $iter726)
{
- $xfer += $output->writeI64($iter705);
+ $xfer += $output->writeI64($iter726);
}
}
$output->writeListEnd();
@@ -22982,9 +23566,9 @@ class PutFileMetadataRequest {
{
$output->writeListBegin(TType::STRING, count($this->metadata));
{
- foreach ($this->metadata as $iter706)
+ foreach ($this->metadata as $iter727)
{
- $xfer += $output->writeString($iter706);
+ $xfer += $output->writeString($iter727);
}
}
$output->writeListEnd();
@@ -23103,14 +23687,14 @@ class ClearFileMetadataRequest {
case 1:
if ($ftype == TType::LST) {
$this->fileIds = array();
- $_size707 = 0;
- $_etype710 = 0;
- $xfer += $input->readListBegin($_etype710, $_size707);
- for ($_i711 = 0; $_i711 < $_size707; ++$_i711)
+ $_size728 = 0;
+ $_etype731 = 0;
+ $xfer += $input->readListBegin($_etype731, $_size728);
+ for ($_i732 = 0; $_i732 < $_size728; ++$_i732)
{
- $elem712 = null;
- $xfer += $input->readI64($elem712);
- $this->fileIds []= $elem712;
+ $elem733 = null;
+ $xfer += $input->readI64($elem733);
+ $this->fileIds []= $elem733;
}
$xfer += $input->readListEnd();
} else {
@@ -23138,9 +23722,9 @@ class ClearFileMetadataRequest {
{
$output->writeListBegin(TType::I64, count($this->fileIds));
{
- foreach ($this->fileIds as $iter713)
+ foreach ($this->fileIds as $iter734)
{
- $xfer += $output->writeI64($iter713);
+ $xfer += $output->writeI64($iter734);
}
}
$output->writeListEnd();
@@ -23424,15 +24008,15 @@ class GetAllFunctionsResponse {
case 1:
if ($ftype == TType::LST) {
$this->functions = array();
- $_size714 = 0;
- $_etype717 = 0;
- $xfer += $input->readListBegin($_etype717, $_size714);
- for ($_i718 = 0; $_i718 < $_size714; ++$_i718)
+ $_size735 = 0;
+ $_etype738 = 0;
+ $xfer += $input->readListBegin($_etype738, $_size735);
+ for ($_i739 = 0; $_i739 < $_size735; ++$_i739)
{
- $elem719 = null;
- $elem719 = new \metastore\Function();
- $xfer += $elem719->read($input);
- $this->functions []= $elem719;
+ $elem740 = null;
+ $elem740 = new \metastore\Function();
+ $xfer += $elem740->read($input);
+ $this->functions []= $elem740;
}
$xfer += $input->readListEnd();
} else {
@@ -23460,9 +24044,9 @@ class GetAllFunctionsResponse {
{
$output->writeListBegin(TType::STRUCT, count($this->functions));
{
- foreach ($this->functions as $iter720)
+ foreach ($this->functions as $iter741)
{
- $xfer += $iter720->write($output);
+ $xfer += $iter741->write($output);
}
}
$output->writeListEnd();
@@ -23526,14 +24110,14 @@ class ClientCapabilities {
case 1:
if ($ftype == TType::LST) {
$this->values = array();
- $_size721 = 0;
- $_etype724 = 0;
- $xfer += $input->readListBegin($_etype724, $_size721);
- for ($_i725 = 0; $_i725 < $_size721; ++$_i725)
+ $_size742 = 0;
+ $_etype745 = 0;
+ $xfer += $input->readListBegin($_etype745, $_size742);
+ for ($_i746 = 0; $_i746 < $_size742; ++$_i746)
{
- $elem726 = null;
- $xfer += $input->readI32($elem726);
- $this->values []= $elem726;
+ $elem747 = null;
+ $xfer += $input->readI32($elem747);
+ $this->values []= $elem747;
}
$xfer += $input->readListEnd();
} else {
@@ -23561,9 +24145,9 @@ class ClientCapabilities {
{
$output->writeListBegin(TType::I32, count($this->values));
{
- foreach ($this->values as $iter727)
+ foreach ($this->values as $iter748)
{
- $xfer += $output->writeI32($iter727);
+ $xfer += $output->writeI32($iter748);
}
}
$output->writeListEnd();
@@ -23897,14 +24481,14 @@ class GetTablesRequest {
case 2:
if ($ftype == TType::LST) {
$this->tblNames = array();
- $_size728 = 0;
- $_etype731 = 0;
- $xfer += $input->readListBegin($_etype731, $_size728);
- for ($_i732 = 0; $_i732 < $_size728; ++$_i732)
+ $_size749 = 0;
+ $_etype752 = 0;
+ $xfer += $input->readListBegin($_etype752, $_size749);
+ for ($_i753 = 0; $_i753 < $_size749; ++$_i753)
{
- $elem733 = null;
- $xfer += $input->readString($elem733);
- $this->tblNames []= $elem733;
+ $elem754 = null;
+ $xfer += $input->readString($elem754);
+ $this->tblNames []= $elem754;
}
$xfer += $input->readListEnd();
} else {
@@ -23952,9 +24536,9 @@ class GetTablesRequest {
{
$output->writeListBegin(TType::STRING, count($this->tblNames));
{
- foreach ($this->tblNames as $iter734)
+ foreach ($this->tblNames as $iter755)
{
- $xfer += $output->writeString($iter734);
+ $xfer += $output->writeString($iter755);
}
}
$output->writeListEnd();
@@ -24032,15 +24616,15 @@ class GetTablesResult {
case 1:
if ($ftype == TType::LST) {
$this->tables = array();
- $_size735 = 0;
- $_etype738 = 0;
- $xfer += $input->readListBegin($_etype738, $_size735);
- for ($_i739 = 0; $_i739 < $_size735; ++$_i739)
+ $_size756 = 0;
+ $_etype759 = 0;
+ $xfer += $input->readListBegin($_etype759, $_size756);
+ for ($_i760 = 0; $_i760 < $_size756; ++$_i760)
{
- $elem740 = null;
- $elem740 = new \metastore\Table();
- $xfer += $elem740->read($input);
- $this->tables []= $elem740;
+ $elem761 = null;
+ $elem761 = new \metastore\Table();
+ $xfer += $elem761->read($input);
+ $this->tables []= $elem761;
}
$xfer += $input->readListEnd();
} else {
@@ -24068,9 +24652,9 @@ class GetTablesResult {
{
$output->writeListBegin(TType::STRUCT, count($this->tables));
{
- foreach ($this->tables as $iter741)
+ foreach ($this->tables as $iter762)
{
- $xfer += $iter741->write($output);
+ $xfer += $iter762->write($output);
}
}
$output->writeListEnd();
@@ -24482,17 +25066,17 @@ class Materialization {
case 1:
if ($ftype == TType::SET) {
$this->tablesUsed = array();
- $_size742 = 0;
- $_etype745 = 0;
- $xfer += $input->readSetBegin($_etype745, $_size742);
- for ($_i746 = 0; $_i746 < $_size742; ++$_i746)
+ $_size763 = 0;
+ $_etype766 = 0;
+ $xfer += $input->readSetBegin($_etype766, $_size763);
+ for ($_i767 = 0; $_i767 < $_size763; ++$_i767)
{
- $elem747 = null;
- $xfer += $input->readString($elem747);
- if (is_scalar($elem747)) {
- $this->tablesUsed[$elem747] = true;
+ $elem768 = null;
+ $xfer += $input->readString($elem768);
+ if (is_scalar($elem768)) {
+ $this->tablesUsed[$elem768] = true;
} else {
- $this->tablesUsed []= $elem747;
+ $this->tablesUsed []= $elem768;
}
}
$xfer += $input->readSetEnd();
@@ -24542,12 +25126,12 @@ class Materialization {
{
$output->writeSetBegin(TType::STRING, count($this->tablesUsed));
{
- foreach ($this->tablesUsed as $iter748 => $iter749)
+ foreach ($this->tablesUsed as $iter769 => $iter770)
{
- if (is_scalar($iter749)) {
- $xfer += $output->writeString($iter748);
+ if (is_scalar($iter770)) {
+ $xfer += $output->writeString($iter769);
} else {
- $xfer += $output->writeString($iter749);
+ $xfer += $output->writeString($iter770);
}
}
}
@@ -25819,15 +26403,15 @@ class WMFullResourcePlan {
case 2:
if ($ftype == TType::LST) {
$this->pools = array();
- $_size750 = 0;
- $_etype753 = 0;
- $xfer += $input->readListBegin($_etype753, $_size750);
- for ($_i754 = 0; $_i754 < $_size750; ++$_i754)
+ $_size771 = 0;
+ $_etype774 = 0;
+ $xfer += $input->readListBegin($_etype774, $_size771);
+ for ($_i775 = 0; $_i775 < $_size771; ++$_i775)
{
- $elem755 = null;
- $elem755 = new \metastore\WMPool();
- $xfer += $elem755->read($input);
- $this->pools []= $elem755;
+ $elem776 = null;
+ $elem776 = new \metastore\WMPool();
+ $xfer += $elem776->read($input);
+ $this->pools []= $elem776;
}
$xfer += $input->readListEnd();
} else {
@@ -25837,15 +26421,15 @@ class WMFullResourcePlan {
case 3:
if ($ftype == TType::LST) {
$this->mappings = array();
- $_size756 = 0;
- $_etype759 = 0;
- $xfer += $input->readListBegin($_etype759, $_size756);
- for ($_i760 = 0; $_i760 < $_size756; ++$_i760)
+ $_size777 = 0;
+ $_etype780 = 0;
+ $xfer += $input->readListBegin($_etype780, $_size777);
+ for ($_i781 = 0; $_i781 < $_size777; ++$_i781)
{
- $elem761 = null;
- $elem761 = new \metastore\WMMapping();
- $xfer += $elem761->read($input);
- $this->mappings []= $elem761;
+ $elem782 = null;
+ $elem782 = new \metastore\WMMapping();
+ $xfer += $elem782->read($input);
+ $this->mappings []= $elem782;
}
$xfer += $input->readListEnd();
} else {
@@ -25855,15 +26439,15 @@ class WMFullResourcePlan {
case 4:
if ($ftype == TType::LST) {
$this->triggers = array();
- $_size762 = 0;
- $_etype765 = 0;
- $xfer += $input->readListBegin($_etype765, $_size762);
- for ($_i766 = 0; $_i766 < $_size762; ++$_i766)
+ $_size783 = 0;
+ $_etype786 = 0;
+ $xfer += $input->readListBegin($_etype786, $_size783);
+ for ($_i787 = 0; $_i787 < $_size783; ++$_i787)
{
- $elem767 = null;
- $elem767 = new \metastore\WMTrigger();
- $xfer += $elem767->read($input);
- $this->triggers []= $elem767;
+ $elem788 = null;
+ $elem788 = new \metastore\WMTrigger();
+ $xfer += $elem788->read($input);
+ $this->triggers []= $elem788;
}
$xfer += $input->readListEnd();
} else {
@@ -25873,15 +26457,15 @@ class WMFullResourcePlan {
case 5:
if ($ftype == TType::LST) {
$this->poolTriggers = array();
- $_size768 = 0;
- $_etype771 = 0;
- $xfer += $input->readListBegin($_etype771, $_size768);
- for ($_i772 = 0; $_i772 < $_size768; ++$_i772)
+ $_size789 = 0;
+ $_etype792 = 0;
+ $xfer += $input->readListBegin($_etype792, $_size789);
+ for ($_i793 = 0; $_i793 < $_size789; ++$_i793)
{
- $elem773 = null;
- $elem773 = new \metastore\WMPoolTrigger();
- $xfer += $elem773->read($input);
- $this->poolTriggers []= $elem773;
+ $elem794 = null;
+ $elem794 = new \metastore\WMPoolTrigger();
+ $xfer += $elem794->read($input);
+ $this->poolTriggers []= $elem794;
}
$xfer += $input->readListEnd();
} else {
@@ -25917,9 +26501,9 @@ class WMFullResourcePlan {
{
$output->writeListBegin(TType::STRUCT, count($this->pools));
{
- foreach ($this->pools as $iter774)
+ foreach ($this->pools as $iter795)
{
- $xfer += $iter774->write($output);
+ $xfer += $iter795->write($output);
}
}
$output->writeListEnd();
@@ -25934,9 +26518,9 @@ class WMFullResourcePlan {
{
$output->writeListBegin(TType::STRUCT, count($this->mappings));
{
- foreach ($this->mappings as $iter775)
+ foreach ($this->mappings as $iter796)
{
- $xfer += $iter775->write($output);
+ $xfer += $iter796->write($output);
}
}
$output->writeListEnd();
@@ -25951,9 +26535,9 @@ class WMFullResourcePlan {
{
$output->writeListBegin(TType::STRUCT, count($this->triggers));
{
- foreach ($this->triggers as $iter776)
+ foreach ($this->triggers as $iter797)
{
- $xfer += $iter776->write($output);
+ $xfer += $iter797->write($output);
}
}
$output->writeListEnd();
@@ -25968,9 +26552,9 @@ class WMFullResourcePlan {
{
$output->writeListBegin(TType::STRUCT, count($this->poolTriggers));
{
- foreach ($this->poolTriggers as $iter777)
+ foreach ($this->poolTriggers as $iter798)
{
- $xfer += $iter777->write($output);
+ $xfer += $iter798->write($output);
}
}
$output->writeListEnd();
@@ -26523,15 +27107,15 @@ class WMGetAllResourcePlanResponse {
case 1:
if ($ftype == TType::LST) {
$this->resourcePlans = array();
- $_size778 = 0;
- $_etype781 = 0;
- $xfer += $input->readListBegin($_etype781, $_size778);
- for ($_i782 = 0; $_i782 < $_size778; ++$_i782)
+ $_size799 = 0;
+ $_etype802 = 0;
+ $xfer += $input->readListBegin($_etype802, $_size799);
+ for ($_i803 = 0; $_i803 < $_size799; ++$_i803)
{
- $elem783 = null;
- $elem783 = new \metastore\WMResourcePlan();
- $xfer += $elem783->read($input);
- $this->resourcePlans []= $elem783;
+ $elem804 = null;
+ $elem804 = new \metastore\WMResourcePlan();
+ $xfer += $elem804->read($input);
+ $this->resourcePlans []= $elem804;
}
$xfer += $input->readListEnd();
} else {
@@ -26559,9 +27143,9 @@ class WMGetAllResourcePlanResponse {
{
$output->writeListBegin(TType::STRUCT, count($this->resourcePlans));
{
- foreach ($this->resourcePlans as $iter784)
+ foreach ($this->resourcePlans as $iter805)
{
- $xfer += $iter784->write($output);
+ $xfer += $iter805->write($output);
}
}
$output->writeListEnd();
@@ -26967,14 +27551,14 @@ class WMValidateResourcePlanResponse {
case 1:
if ($ftype == TType::LST) {
$this->errors = array();
- $_size785 = 0;
- $_etype788 = 0;
- $xfer += $input->readListBegin($_etype788, $_size785);
- for ($_i789 = 0; $_i789 < $_size785; ++$_i789)
+ $_size806 = 0;
+ $_etype809 = 0;
+ $xfer += $input->readListBegin($_etype809, $_size806);
+ for ($_i810 = 0; $_i810 < $_size806; ++$_i810)
{
- $elem790 = null;
- $xfer += $input->readString($elem790);
- $this->errors []= $elem790;
+ $elem811 = null;
+ $xfer += $input->readString($elem811);
+ $this->errors []= $elem811;
}
$xfer += $input->readListEnd();
} else {
@@ -26984,14 +27568,14 @@ class WMValidateResourcePlanResponse {
case 2:
if ($ftype == TType::LST) {
$this->warnings = array();
- $_size791 = 0;
- $_etype794 = 0;
- $xfer += $input->readListBegin($_etype794, $_size791);
- for ($_i795 = 0; $_i795 < $_size791; ++$_i795)
+ $_size812 = 0;
+ $_etype815 = 0;
+ $xfer += $input->readListBegin($_etype815, $_size812);
+ for ($_i816 = 0; $_i816 < $_size812; ++$_i816)
{
- $elem796 = null;
- $xfer += $input->readString($elem796);
- $this->warnings []= $elem796;
+ $elem817 = null;
+ $xfer += $input->readString($elem817);
+ $this->warnings []= $elem817;
}
$xfer += $input->readListEnd();
} else {
@@ -27019,9 +27603,9 @@ class WMValidateResourcePlanResponse {
{
$output->writeListBegin(TType::STRING, count($this->errors));
{
- foreach ($this->errors as $iter797)
+ foreach ($this->errors as $iter818)
{
- $xfer += $output->writeString($iter797);
+ $xfer += $output->writeString($iter818);
}
}
$output->writeListEnd();
@@ -27036,9 +27620,9 @@ class WMValidateResourcePlanResponse {
{
$output->writeListBegin(TType::STRING, count($this->warnings));
{
- foreach ($this->warnings as $iter798)
+ foreach ($this->warnings as $iter819)
{
- $xfer += $output->writeString($iter798);
+ $xfer += $output->writeString($iter819);
}
}
$output->writeListEnd();
@@ -27711,15 +28295,15 @@ class WMGetTriggersForResourePlanResponse {
case 1:
if ($ftype == TType::LST) {
$this->triggers = array();
- $_size799 = 0;
- $_etype802 = 0;
- $xfer += $input->readListBegin($_etype802, $_size799);
- for ($_i803 = 0; $_i803 < $_size799; ++$_i803)
+ $_size820 = 0;
+ $_etype823 = 0;
+ $xfer += $input->readListBegin($_etype823, $_size820);
+ for ($_i824 = 0; $_i824 < $_size820; ++$_i824)
{
- $elem804 = null;
- $elem804 = new \metastore\WMTrigger();
- $xfer += $elem804->read($input);
- $this->triggers []= $elem804;
+ $elem825 = null;
+ $elem825 = new \metastore\WMTrigger();
+ $xfer += $elem825->read($input);
+ $this->triggers []= $elem825;
}
$xfer += $input->readListEnd();
} else {
@@ -27747,9 +28331,9 @@ class WMGetTriggersForResourePlanResponse {
{
$output->writeListBegin(TType::STRUCT, count($this->triggers));
{
- foreach ($this->triggers as $iter805)
+ foreach ($this->triggers as $iter826)
{
- $xfer += $iter805->write($output);
+ $xfer += $iter826->write($output);
}
}
$output->writeListEnd();
@@ -29333,15 +29917,15 @@ class SchemaVersion {
case 4:
if ($ftype == TType::LST) {
$this->cols = array();
- $_size806 = 0;
- $_etype809 = 0;
- $xfer += $input->readListBegin($_etype809, $_size806);
- for ($_i810 = 0; $_i810 < $_size806; ++$_i810)
+ $_size827 = 0;
+ $_etype830 = 0;
+ $xfer += $input->readListBegin($_etype830, $_size827);
+ for ($_i831 = 0; $_i831 < $_size827; ++$_i831)
{
- $elem811 = null;
- $elem811 = new \metastore\FieldSchema();
- $xfer += $elem811->read($input);
- $this->cols []= $elem811;
+ $elem832 = null;
+ $elem832 = new \metastore\FieldSchema();
+ $xfer += $elem832->read($input);
+ $this->cols []= $elem832;
}
$xfer += $input->readListEnd();
} else {
@@ -29430,9 +30014,9 @@ class SchemaVersion {
{
$output->writeListBegin(TType::STRUCT, count($this->cols));
{
- foreach ($this->cols as $iter812)
+ foreach ($this->cols as $iter833)
{
- $xfer += $iter812->write($output);
+ $xfer += $iter833->write($output);
}
}
$output->writeListEnd();
@@ -29754,15 +30338,15 @@ class FindSchemasByColsResp {
case 1:
if ($ftype == TType::LST) {
$this->schemaVersions = array();
- $_size813 = 0;
- $_etype816 = 0;
- $xfer += $input->readListBegin($_etype816, $_size813);
- for ($_i817 = 0; $_i817 < $_size813; ++$_i817)
+ $_size834 = 0;
+ $_etype837 = 0;
+ $xfer += $input->readListBegin($_etype837, $_size834);
+ for ($_i838 = 0; $_i838 < $_size834; ++$_i838)
{
- $elem818 = null;
- $elem818 = new \metastore\SchemaVersionDescriptor();
- $xfer += $elem818->read($input);
- $this->schemaVersions []= $elem818;
+ $elem839 = null;
+ $elem839 = new \metastore\SchemaVersionDescriptor();
+ $xfer += $elem839->read($input);
+ $this->schemaVersions []= $elem839;
}
$xfer += $input->readListEnd();
} else {
@@ -29790,9 +30374,9 @@ class FindSchemasByColsResp {
{
$output->writeListBegin(TType::STRUCT, count($this->schemaVersions));
{
- foreach ($this->schemaVersions as $iter819)
+ foreach ($this->schemaVersions as $iter840)
{
- $xfer += $iter819->write($output);
+ $xfer += $iter840->write($output);
}
}
$output->writeListEnd();