hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ser...@apache.org
Subject [44/50] [abbrv] hive git commit: HIVE-14671 : merge master into hive-14535 (exim conflicts merge 1) (Sergey Shelukhin)
Date Tue, 15 Nov 2016 20:21:16 GMT
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
----------------------------------------------------------------------


Mime
View raw message