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 2016/11/15 20:21:16 UTC
[44/50] [abbrv] hive git commit: HIVE-14671 : merge master into
hive-14535 (exim conflicts merge 1) (Sergey Shelukhin)
http://git-wip-us.apache.org/repos/asf/hive/blob/b3914c37/metastore/src/gen/thrift/gen-php/metastore/Types.php
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-php/metastore/Types.php
index 9dd14d7,ecb6254..7dfeb44
--- a/metastore/src/gen/thrift/gen-php/metastore/Types.php
+++ b/metastore/src/gen/thrift/gen-php/metastore/Types.php
@@@ -17974,444 -17994,141 +17981,1006 @@@ class HeartbeatWriteIdRequest
public function write($output) {
$xfer = 0;
- $xfer += $output->writeStructBegin('GetTablesRequest');
+ $xfer += $output->writeStructBegin('HeartbeatWriteIdRequest');
+ if ($this->dbName !== null) {
+ $xfer += $output->writeFieldBegin('dbName', TType::STRING, 1);
+ $xfer += $output->writeString($this->dbName);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->tblName !== null) {
+ $xfer += $output->writeFieldBegin('tblName', TType::STRING, 2);
+ $xfer += $output->writeString($this->tblName);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->writeId !== null) {
+ $xfer += $output->writeFieldBegin('writeId', TType::I64, 3);
+ $xfer += $output->writeI64($this->writeId);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class HeartbeatWriteIdResult {
+ static $_TSPEC;
+
+
+ public function __construct() {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ );
+ }
+ }
+
+ public function getName() {
+ return 'HeartbeatWriteIdResult';
+ }
+
+ 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)
+ {
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('HeartbeatWriteIdResult');
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class GetValidWriteIdsRequest {
+ static $_TSPEC;
+
+ /**
+ * @var string
+ */
+ public $dbName = null;
+ /**
+ * @var string
+ */
+ public $tblName = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'dbName',
+ 'type' => TType::STRING,
+ ),
+ 2 => array(
+ 'var' => 'tblName',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['dbName'])) {
+ $this->dbName = $vals['dbName'];
+ }
+ if (isset($vals['tblName'])) {
+ $this->tblName = $vals['tblName'];
+ }
+ }
+ }
+
+ 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::STRING) {
+ $xfer += $input->readString($this->dbName);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->tblName);
+ } 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->dbName !== null) {
+ $xfer += $output->writeFieldBegin('dbName', TType::STRING, 1);
+ $xfer += $output->writeString($this->dbName);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->tblName !== null) {
+ $xfer += $output->writeFieldBegin('tblName', TType::STRING, 2);
+ $xfer += $output->writeString($this->tblName);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class GetValidWriteIdsResult {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $lowWatermarkId = null;
+ /**
+ * @var int
+ */
+ public $highWatermarkId = null;
+ /**
+ * @var bool
+ */
+ public $areIdsValid = null;
+ /**
+ * @var int[]
+ */
+ public $ids = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'lowWatermarkId',
+ 'type' => TType::I64,
+ ),
+ 2 => array(
+ 'var' => 'highWatermarkId',
+ 'type' => TType::I64,
+ ),
+ 3 => array(
+ 'var' => 'areIdsValid',
+ 'type' => TType::BOOL,
+ ),
+ 4 => array(
+ 'var' => 'ids',
+ 'type' => TType::LST,
+ 'etype' => TType::I64,
+ 'elem' => array(
+ 'type' => TType::I64,
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['lowWatermarkId'])) {
+ $this->lowWatermarkId = $vals['lowWatermarkId'];
+ }
+ if (isset($vals['highWatermarkId'])) {
+ $this->highWatermarkId = $vals['highWatermarkId'];
+ }
+ if (isset($vals['areIdsValid'])) {
+ $this->areIdsValid = $vals['areIdsValid'];
+ }
+ if (isset($vals['ids'])) {
+ $this->ids = $vals['ids'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'GetValidWriteIdsResult';
+ }
+
+ 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->lowWatermarkId);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::I64) {
+ $xfer += $input->readI64($this->highWatermarkId);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::BOOL) {
+ $xfer += $input->readBool($this->areIdsValid);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::LST) {
+ $this->ids = array();
+ $_size562 = 0;
+ $_etype565 = 0;
+ $xfer += $input->readListBegin($_etype565, $_size562);
+ for ($_i566 = 0; $_i566 < $_size562; ++$_i566)
+ {
+ $elem567 = null;
+ $xfer += $input->readI64($elem567);
+ $this->ids []= $elem567;
+ }
+ $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('GetValidWriteIdsResult');
+ if ($this->lowWatermarkId !== null) {
+ $xfer += $output->writeFieldBegin('lowWatermarkId', TType::I64, 1);
+ $xfer += $output->writeI64($this->lowWatermarkId);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->highWatermarkId !== null) {
+ $xfer += $output->writeFieldBegin('highWatermarkId', TType::I64, 2);
+ $xfer += $output->writeI64($this->highWatermarkId);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->areIdsValid !== null) {
+ $xfer += $output->writeFieldBegin('areIdsValid', TType::BOOL, 3);
+ $xfer += $output->writeBool($this->areIdsValid);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->ids !== null) {
+ if (!is_array($this->ids)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('ids', TType::LST, 4);
+ {
+ $output->writeListBegin(TType::I64, count($this->ids));
+ {
+ foreach ($this->ids as $iter568)
+ {
+ $xfer += $output->writeI64($iter568);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class GetAllFunctionsResponse {
+ static $_TSPEC;
+
+ /**
+ * @var \metastore\Function[]
+ */
+ public $functions = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'functions',
+ 'type' => TType::LST,
+ 'etype' => TType::STRUCT,
+ 'elem' => array(
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\Function',
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['functions'])) {
+ $this->functions = $vals['functions'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'GetAllFunctionsResponse';
+ }
+
+ 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->functions = array();
+ $_size569 = 0;
+ $_etype572 = 0;
+ $xfer += $input->readListBegin($_etype572, $_size569);
+ for ($_i573 = 0; $_i573 < $_size569; ++$_i573)
+ {
+ $elem574 = null;
+ $elem574 = new \metastore\Function();
+ $xfer += $elem574->read($input);
+ $this->functions []= $elem574;
+ }
+ $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('GetAllFunctionsResponse');
+ if ($this->functions !== null) {
+ if (!is_array($this->functions)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('functions', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::STRUCT, count($this->functions));
+ {
+ foreach ($this->functions as $iter575)
+ {
+ $xfer += $iter575->write($output);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
++ $xfer += $output->writeStructEnd();
++ return $xfer;
++ }
++
++}
++
++class ClientCapabilities {
++ static $_TSPEC;
++
++ /**
++ * @var int[]
++ */
++ public $values = null;
++
++ public function __construct($vals=null) {
++ if (!isset(self::$_TSPEC)) {
++ self::$_TSPEC = array(
++ 1 => array(
++ 'var' => 'values',
++ 'type' => TType::LST,
++ 'etype' => TType::I32,
++ 'elem' => array(
++ 'type' => TType::I32,
++ ),
++ ),
++ );
++ }
++ if (is_array($vals)) {
++ if (isset($vals['values'])) {
++ $this->values = $vals['values'];
++ }
++ }
++ }
++
++ public function getName() {
++ return 'ClientCapabilities';
++ }
++
++ 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->values = array();
++ $_size576 = 0;
++ $_etype579 = 0;
++ $xfer += $input->readListBegin($_etype579, $_size576);
++ for ($_i580 = 0; $_i580 < $_size576; ++$_i580)
++ {
++ $elem581 = null;
++ $xfer += $input->readI32($elem581);
++ $this->values []= $elem581;
++ }
++ $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('ClientCapabilities');
++ if ($this->values !== null) {
++ if (!is_array($this->values)) {
++ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
++ }
++ $xfer += $output->writeFieldBegin('values', TType::LST, 1);
++ {
++ $output->writeListBegin(TType::I32, count($this->values));
++ {
++ foreach ($this->values as $iter582)
++ {
++ $xfer += $output->writeI32($iter582);
++ }
++ }
++ $output->writeListEnd();
++ }
++ $xfer += $output->writeFieldEnd();
++ }
++ $xfer += $output->writeFieldStop();
++ $xfer += $output->writeStructEnd();
++ return $xfer;
++ }
++
++}
++
++class GetTableRequest {
++ static $_TSPEC;
++
++ /**
++ * @var string
++ */
++ public $dbName = null;
++ /**
++ * @var string
++ */
++ public $tblName = null;
++ /**
++ * @var \metastore\ClientCapabilities
++ */
++ public $capabilities = null;
++
++ public function __construct($vals=null) {
++ if (!isset(self::$_TSPEC)) {
++ self::$_TSPEC = array(
++ 1 => array(
++ 'var' => 'dbName',
++ 'type' => TType::STRING,
++ ),
++ 2 => array(
++ 'var' => 'tblName',
++ 'type' => TType::STRING,
++ ),
++ 3 => array(
++ 'var' => 'capabilities',
++ 'type' => TType::STRUCT,
++ 'class' => '\metastore\ClientCapabilities',
++ ),
++ );
++ }
++ if (is_array($vals)) {
++ if (isset($vals['dbName'])) {
++ $this->dbName = $vals['dbName'];
++ }
++ if (isset($vals['tblName'])) {
++ $this->tblName = $vals['tblName'];
++ }
++ if (isset($vals['capabilities'])) {
++ $this->capabilities = $vals['capabilities'];
++ }
++ }
++ }
++
++ public function getName() {
++ return 'GetTableRequest';
++ }
++
++ 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->dbName);
++ } else {
++ $xfer += $input->skip($ftype);
++ }
++ break;
++ case 2:
++ if ($ftype == TType::STRING) {
++ $xfer += $input->readString($this->tblName);
++ } else {
++ $xfer += $input->skip($ftype);
++ }
++ break;
++ case 3:
++ if ($ftype == TType::STRUCT) {
++ $this->capabilities = new \metastore\ClientCapabilities();
++ $xfer += $this->capabilities->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('GetTableRequest');
++ if ($this->dbName !== null) {
++ $xfer += $output->writeFieldBegin('dbName', TType::STRING, 1);
++ $xfer += $output->writeString($this->dbName);
++ $xfer += $output->writeFieldEnd();
++ }
++ if ($this->tblName !== null) {
++ $xfer += $output->writeFieldBegin('tblName', TType::STRING, 2);
++ $xfer += $output->writeString($this->tblName);
++ $xfer += $output->writeFieldEnd();
++ }
++ if ($this->capabilities !== null) {
++ if (!is_object($this->capabilities)) {
++ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
++ }
++ $xfer += $output->writeFieldBegin('capabilities', TType::STRUCT, 3);
++ $xfer += $this->capabilities->write($output);
++ $xfer += $output->writeFieldEnd();
++ }
++ $xfer += $output->writeFieldStop();
++ $xfer += $output->writeStructEnd();
++ return $xfer;
++ }
++
++}
++
++class GetTableResult {
++ static $_TSPEC;
++
++ /**
++ * @var \metastore\Table
++ */
++ public $table = null;
++
++ public function __construct($vals=null) {
++ if (!isset(self::$_TSPEC)) {
++ self::$_TSPEC = array(
++ 1 => array(
++ 'var' => 'table',
++ 'type' => TType::STRUCT,
++ 'class' => '\metastore\Table',
++ ),
++ );
++ }
++ if (is_array($vals)) {
++ if (isset($vals['table'])) {
++ $this->table = $vals['table'];
++ }
++ }
++ }
++
++ public function getName() {
++ return 'GetTableResult';
++ }
++
++ 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->table = new \metastore\Table();
++ $xfer += $this->table->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('GetTableResult');
++ if ($this->table !== null) {
++ if (!is_object($this->table)) {
++ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
++ }
++ $xfer += $output->writeFieldBegin('table', TType::STRUCT, 1);
++ $xfer += $this->table->write($output);
++ $xfer += $output->writeFieldEnd();
++ }
++ $xfer += $output->writeFieldStop();
++ $xfer += $output->writeStructEnd();
++ return $xfer;
++ }
++
++}
++
++class GetTablesRequest {
++ static $_TSPEC;
++
++ /**
++ * @var string
++ */
++ public $dbName = null;
++ /**
++ * @var string[]
++ */
++ public $tblNames = null;
++ /**
++ * @var \metastore\ClientCapabilities
++ */
++ public $capabilities = null;
++
++ public function __construct($vals=null) {
++ if (!isset(self::$_TSPEC)) {
++ self::$_TSPEC = array(
++ 1 => array(
++ 'var' => 'dbName',
++ 'type' => TType::STRING,
++ ),
++ 2 => array(
++ 'var' => 'tblNames',
++ 'type' => TType::LST,
++ 'etype' => TType::STRING,
++ 'elem' => array(
++ 'type' => TType::STRING,
++ ),
++ ),
++ 3 => array(
++ 'var' => 'capabilities',
++ 'type' => TType::STRUCT,
++ 'class' => '\metastore\ClientCapabilities',
++ ),
++ );
++ }
++ if (is_array($vals)) {
++ if (isset($vals['dbName'])) {
++ $this->dbName = $vals['dbName'];
++ }
++ if (isset($vals['tblNames'])) {
++ $this->tblNames = $vals['tblNames'];
++ }
++ if (isset($vals['capabilities'])) {
++ $this->capabilities = $vals['capabilities'];
++ }
++ }
++ }
++
++ public function getName() {
++ return 'GetTablesRequest';
++ }
++
++ 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->dbName);
++ } else {
++ $xfer += $input->skip($ftype);
++ }
++ break;
++ case 2:
++ if ($ftype == TType::LST) {
++ $this->tblNames = array();
++ $_size583 = 0;
++ $_etype586 = 0;
++ $xfer += $input->readListBegin($_etype586, $_size583);
++ for ($_i587 = 0; $_i587 < $_size583; ++$_i587)
++ {
++ $elem588 = null;
++ $xfer += $input->readString($elem588);
++ $this->tblNames []= $elem588;
++ }
++ $xfer += $input->readListEnd();
++ } else {
++ $xfer += $input->skip($ftype);
++ }
++ break;
++ case 3:
++ if ($ftype == TType::STRUCT) {
++ $this->capabilities = new \metastore\ClientCapabilities();
++ $xfer += $this->capabilities->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('GetTablesRequest');
+ if ($this->dbName !== null) {
+ $xfer += $output->writeFieldBegin('dbName', TType::STRING, 1);
+ $xfer += $output->writeString($this->dbName);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->tblNames !== null) {
+ if (!is_array($this->tblNames)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('tblNames', TType::LST, 2);
+ {
+ $output->writeListBegin(TType::STRING, count($this->tblNames));
+ {
- foreach ($this->tblNames as $iter582)
++ foreach ($this->tblNames as $iter589)
+ {
- $xfer += $output->writeString($iter582);
++ $xfer += $output->writeString($iter589);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->capabilities !== null) {
+ if (!is_object($this->capabilities)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('capabilities', TType::STRUCT, 3);
+ $xfer += $this->capabilities->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+ }
+
+ class GetTablesResult {
+ static $_TSPEC;
+
+ /**
+ * @var \metastore\Table[]
+ */
+ public $tables = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'tables',
+ 'type' => TType::LST,
+ 'etype' => TType::STRUCT,
+ 'elem' => array(
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\Table',
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['tables'])) {
+ $this->tables = $vals['tables'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'GetTablesResult';
+ }
+
+ 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->tables = array();
- $_size583 = 0;
- $_etype586 = 0;
- $xfer += $input->readListBegin($_etype586, $_size583);
- for ($_i587 = 0; $_i587 < $_size583; ++$_i587)
++ $_size590 = 0;
++ $_etype593 = 0;
++ $xfer += $input->readListBegin($_etype593, $_size590);
++ for ($_i594 = 0; $_i594 < $_size590; ++$_i594)
+ {
- $elem588 = null;
- $elem588 = new \metastore\Table();
- $xfer += $elem588->read($input);
- $this->tables []= $elem588;
++ $elem595 = null;
++ $elem595 = new \metastore\Table();
++ $xfer += $elem595->read($input);
++ $this->tables []= $elem595;
+ }
+ $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('GetTablesResult');
+ if ($this->tables !== null) {
+ if (!is_array($this->tables)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('tables', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::STRUCT, count($this->tables));
+ {
- foreach ($this->tables as $iter589)
++ foreach ($this->tables as $iter596)
+ {
- $xfer += $iter589->write($output);
++ $xfer += $iter596->write($output);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/b3914c37/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote
----------------------------------------------------------------------