FAQ
http://git-wip-us.apache.org/repos/asf/hive/blob/96c9ee64/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php
index ae47cb5..a2e5b05 100644
--- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php
+++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php
@@ -394,6 +394,19 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf {
     */
    public function exchange_partition(array $partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name);
    /**
+ * @param array $partitionSpecs
+ * @param string $source_db
+ * @param string $source_table_name
+ * @param string $dest_db
+ * @param string $dest_table_name
+ * @return \metastore\Partition[]
+ * @throws \metastore\MetaException
+ * @throws \metastore\NoSuchObjectException
+ * @throws \metastore\InvalidObjectException
+ * @throws \metastore\InvalidInputException
+ */
+ public function exchange_partitions(array $partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name);
+ /**
     * @param string $db_name
     * @param string $tbl_name
     * @param string[] $part_vals
@@ -3599,6 +3612,73 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas
      throw new \Exception("exchange_partition failed: unknown result");
    }

+ public function exchange_partitions(array $partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name)
+ {
+ $this->send_exchange_partitions($partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name);
+ return $this->recv_exchange_partitions();
+ }
+
+ public function send_exchange_partitions(array $partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name)
+ {
+ $args = new \metastore\ThriftHiveMetastore_exchange_partitions_args();
+ $args->partitionSpecs = $partitionSpecs;
+ $args->source_db = $source_db;
+ $args->source_table_name = $source_table_name;
+ $args->dest_db = $dest_db;
+ $args->dest_table_name = $dest_table_name;
+ $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'exchange_partitions', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('exchange_partitions', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_exchange_partitions()
+ {
+ $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_exchange_partitions_result', $this->input_->isStrictRead());
+ else
+ {
+ $rseqid = 0;
+ $fname = null;
+ $mtype = 0;
+
+ $this->input_->readMessageBegin($fname, $mtype, $rseqid);
+ if ($mtype == TMessageType::EXCEPTION) {
+ $x = new TApplicationException();
+ $x->read($this->input_);
+ $this->input_->readMessageEnd();
+ throw $x;
+ }
+ $result = new \metastore\ThriftHiveMetastore_exchange_partitions_result();
+ $result->read($this->input_);
+ $this->input_->readMessageEnd();
+ }
+ if ($result->success !== null) {
+ return $result->success;
+ }
+ if ($result->o1 !== null) {
+ throw $result->o1;
+ }
+ if ($result->o2 !== null) {
+ throw $result->o2;
+ }
+ if ($result->o3 !== null) {
+ throw $result->o3;
+ }
+ if ($result->o4 !== null) {
+ throw $result->o4;
+ }
+ throw new \Exception("exchange_partitions failed: unknown result");
+ }
+
    public function get_partition_with_auth($db_name, $tbl_name, array $part_vals, $user_name, array $group_names)
    {
      $this->send_get_partition_with_auth($db_name, $tbl_name, $part_vals, $user_name, $group_names);
@@ -19199,6 +19279,410 @@ class ThriftHiveMetastore_exchange_partition_result {

  }

+class ThriftHiveMetastore_exchange_partitions_args {
+ static $_TSPEC;
+
+ /**
+ * @var array
+ */
+ public $partitionSpecs = null;
+ /**
+ * @var string
+ */
+ public $source_db = null;
+ /**
+ * @var string
+ */
+ public $source_table_name = null;
+ /**
+ * @var string
+ */
+ public $dest_db = null;
+ /**
+ * @var string
+ */
+ public $dest_table_name = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'partitionSpecs',
+ 'type' => TType::MAP,
+ 'ktype' => TType::STRING,
+ 'vtype' => TType::STRING,
+ 'key' => array(
+ 'type' => TType::STRING,
+ ),
+ 'val' => array(
+ 'type' => TType::STRING,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'source_db',
+ 'type' => TType::STRING,
+ ),
+ 3 => array(
+ 'var' => 'source_table_name',
+ 'type' => TType::STRING,
+ ),
+ 4 => array(
+ 'var' => 'dest_db',
+ 'type' => TType::STRING,
+ ),
+ 5 => array(
+ 'var' => 'dest_table_name',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['partitionSpecs'])) {
+ $this->partitionSpecs = $vals['partitionSpecs'];
+ }
+ if (isset($vals['source_db'])) {
+ $this->source_db = $vals['source_db'];
+ }
+ if (isset($vals['source_table_name'])) {
+ $this->source_table_name = $vals['source_table_name'];
+ }
+ if (isset($vals['dest_db'])) {
+ $this->dest_db = $vals['dest_db'];
+ }
+ if (isset($vals['dest_table_name'])) {
+ $this->dest_table_name = $vals['dest_table_name'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_exchange_partitions_args';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::MAP) {
+ $this->partitionSpecs = array();
+ $_size616 = 0;
+ $_ktype617 = 0;
+ $_vtype618 = 0;
+ $xfer += $input->readMapBegin($_ktype617, $_vtype618, $_size616);
+ for ($_i620 = 0; $_i620 < $_size616; ++$_i620)
+ {
+ $key621 = '';
+ $val622 = '';
+ $xfer += $input->readString($key621);
+ $xfer += $input->readString($val622);
+ $this->partitionSpecs[$key621] = $val622;
+ }
+ $xfer += $input->readMapEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->source_db);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->source_table_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->dest_db);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 5:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->dest_table_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('ThriftHiveMetastore_exchange_partitions_args');
+ if ($this->partitionSpecs !== null) {
+ if (!is_array($this->partitionSpecs)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('partitionSpecs', TType::MAP, 1);
+ {
+ $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs));
+ {
+ foreach ($this->partitionSpecs as $kiter623 => $viter624)
+ {
+ $xfer += $output->writeString($kiter623);
+ $xfer += $output->writeString($viter624);
+ }
+ }
+ $output->writeMapEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->source_db !== null) {
+ $xfer += $output->writeFieldBegin('source_db', TType::STRING, 2);
+ $xfer += $output->writeString($this->source_db);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->source_table_name !== null) {
+ $xfer += $output->writeFieldBegin('source_table_name', TType::STRING, 3);
+ $xfer += $output->writeString($this->source_table_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->dest_db !== null) {
+ $xfer += $output->writeFieldBegin('dest_db', TType::STRING, 4);
+ $xfer += $output->writeString($this->dest_db);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->dest_table_name !== null) {
+ $xfer += $output->writeFieldBegin('dest_table_name', TType::STRING, 5);
+ $xfer += $output->writeString($this->dest_table_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class ThriftHiveMetastore_exchange_partitions_result {
+ static $_TSPEC;
+
+ /**
+ * @var \metastore\Partition[]
+ */
+ public $success = null;
+ /**
+ * @var \metastore\MetaException
+ */
+ public $o1 = null;
+ /**
+ * @var \metastore\NoSuchObjectException
+ */
+ public $o2 = null;
+ /**
+ * @var \metastore\InvalidObjectException
+ */
+ public $o3 = null;
+ /**
+ * @var \metastore\InvalidInputException
+ */
+ public $o4 = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::LST,
+ 'etype' => TType::STRUCT,
+ 'elem' => array(
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\Partition',
+ ),
+ ),
+ 1 => array(
+ 'var' => 'o1',
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\MetaException',
+ ),
+ 2 => array(
+ 'var' => 'o2',
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\NoSuchObjectException',
+ ),
+ 3 => array(
+ 'var' => 'o3',
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\InvalidObjectException',
+ ),
+ 4 => array(
+ 'var' => 'o4',
+ 'type' => TType::STRUCT,
+ 'class' => '\metastore\InvalidInputException',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['success'])) {
+ $this->success = $vals['success'];
+ }
+ if (isset($vals['o1'])) {
+ $this->o1 = $vals['o1'];
+ }
+ if (isset($vals['o2'])) {
+ $this->o2 = $vals['o2'];
+ }
+ if (isset($vals['o3'])) {
+ $this->o3 = $vals['o3'];
+ }
+ if (isset($vals['o4'])) {
+ $this->o4 = $vals['o4'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_exchange_partitions_result';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 0:
+ if ($ftype == TType::LST) {
+ $this->success = array();
+ $_size625 = 0;
+ $_etype628 = 0;
+ $xfer += $input->readListBegin($_etype628, $_size625);
+ for ($_i629 = 0; $_i629 < $_size625; ++$_i629)
+ {
+ $elem630 = null;
+ $elem630 = new \metastore\Partition();
+ $xfer += $elem630->read($input);
+ $this->success []= $elem630;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->o1 = new \metastore\MetaException();
+ $xfer += $this->o1->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->o2 = new \metastore\NoSuchObjectException();
+ $xfer += $this->o2->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRUCT) {
+ $this->o3 = new \metastore\InvalidObjectException();
+ $xfer += $this->o3->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::STRUCT) {
+ $this->o4 = new \metastore\InvalidInputException();
+ $xfer += $this->o4->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('ThriftHiveMetastore_exchange_partitions_result');
+ if ($this->success !== null) {
+ if (!is_array($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::LST, 0);
+ {
+ $output->writeListBegin(TType::STRUCT, count($this->success));
+ {
+ foreach ($this->success as $iter631)
+ {
+ $xfer += $iter631->write($output);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->o1 !== null) {
+ $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1);
+ $xfer += $this->o1->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->o2 !== null) {
+ $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2);
+ $xfer += $this->o2->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->o3 !== null) {
+ $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3);
+ $xfer += $this->o3->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->o4 !== null) {
+ $xfer += $output->writeFieldBegin('o4', TType::STRUCT, 4);
+ $xfer += $this->o4->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
  class ThriftHiveMetastore_get_partition_with_auth_args {
    static $_TSPEC;

@@ -19311,14 +19795,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args {
          case 3:
            if ($ftype == TType::LST) {
              $this->part_vals = array();
- $_size616 = 0;
- $_etype619 = 0;
- $xfer += $input->readListBegin($_etype619, $_size616);
- for ($_i620 = 0; $_i620 < $_size616; ++$_i620)
+ $_size632 = 0;
+ $_etype635 = 0;
+ $xfer += $input->readListBegin($_etype635, $_size632);
+ for ($_i636 = 0; $_i636 < $_size632; ++$_i636)
              {
- $elem621 = null;
- $xfer += $input->readString($elem621);
- $this->part_vals []= $elem621;
+ $elem637 = null;
+ $xfer += $input->readString($elem637);
+ $this->part_vals []= $elem637;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -19335,14 +19819,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args {
          case 5:
            if ($ftype == TType::LST) {
              $this->group_names = array();
- $_size622 = 0;
- $_etype625 = 0;
- $xfer += $input->readListBegin($_etype625, $_size622);
- for ($_i626 = 0; $_i626 < $_size622; ++$_i626)
+ $_size638 = 0;
+ $_etype641 = 0;
+ $xfer += $input->readListBegin($_etype641, $_size638);
+ for ($_i642 = 0; $_i642 < $_size638; ++$_i642)
              {
- $elem627 = null;
- $xfer += $input->readString($elem627);
- $this->group_names []= $elem627;
+ $elem643 = null;
+ $xfer += $input->readString($elem643);
+ $this->group_names []= $elem643;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -19380,9 +19864,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args {
        {
          $output->writeListBegin(TType::STRING, count($this->part_vals));
          {
- foreach ($this->part_vals as $iter628)
+ foreach ($this->part_vals as $iter644)
            {
- $xfer += $output->writeString($iter628);
+ $xfer += $output->writeString($iter644);
            }
          }
          $output->writeListEnd();
@@ -19402,9 +19886,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args {
        {
          $output->writeListBegin(TType::STRING, count($this->group_names));
          {
- foreach ($this->group_names as $iter629)
+ foreach ($this->group_names as $iter645)
            {
- $xfer += $output->writeString($iter629);
+ $xfer += $output->writeString($iter645);
            }
          }
          $output->writeListEnd();
@@ -19995,15 +20479,15 @@ class ThriftHiveMetastore_get_partitions_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size630 = 0;
- $_etype633 = 0;
- $xfer += $input->readListBegin($_etype633, $_size630);
- for ($_i634 = 0; $_i634 < $_size630; ++$_i634)
+ $_size646 = 0;
+ $_etype649 = 0;
+ $xfer += $input->readListBegin($_etype649, $_size646);
+ for ($_i650 = 0; $_i650 < $_size646; ++$_i650)
              {
- $elem635 = null;
- $elem635 = new \metastore\Partition();
- $xfer += $elem635->read($input);
- $this->success []= $elem635;
+ $elem651 = null;
+ $elem651 = new \metastore\Partition();
+ $xfer += $elem651->read($input);
+ $this->success []= $elem651;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -20047,9 +20531,9 @@ class ThriftHiveMetastore_get_partitions_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter636)
+ foreach ($this->success as $iter652)
            {
- $xfer += $iter636->write($output);
+ $xfer += $iter652->write($output);
            }
          }
          $output->writeListEnd();
@@ -20195,14 +20679,14 @@ class ThriftHiveMetastore_get_partitions_with_auth_args {
          case 5:
            if ($ftype == TType::LST) {
              $this->group_names = array();
- $_size637 = 0;
- $_etype640 = 0;
- $xfer += $input->readListBegin($_etype640, $_size637);
- for ($_i641 = 0; $_i641 < $_size637; ++$_i641)
+ $_size653 = 0;
+ $_etype656 = 0;
+ $xfer += $input->readListBegin($_etype656, $_size653);
+ for ($_i657 = 0; $_i657 < $_size653; ++$_i657)
              {
- $elem642 = null;
- $xfer += $input->readString($elem642);
- $this->group_names []= $elem642;
+ $elem658 = null;
+ $xfer += $input->readString($elem658);
+ $this->group_names []= $elem658;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -20250,9 +20734,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_args {
        {
          $output->writeListBegin(TType::STRING, count($this->group_names));
          {
- foreach ($this->group_names as $iter643)
+ foreach ($this->group_names as $iter659)
            {
- $xfer += $output->writeString($iter643);
+ $xfer += $output->writeString($iter659);
            }
          }
          $output->writeListEnd();
@@ -20341,15 +20825,15 @@ class ThriftHiveMetastore_get_partitions_with_auth_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size644 = 0;
- $_etype647 = 0;
- $xfer += $input->readListBegin($_etype647, $_size644);
- for ($_i648 = 0; $_i648 < $_size644; ++$_i648)
+ $_size660 = 0;
+ $_etype663 = 0;
+ $xfer += $input->readListBegin($_etype663, $_size660);
+ for ($_i664 = 0; $_i664 < $_size660; ++$_i664)
              {
- $elem649 = null;
- $elem649 = new \metastore\Partition();
- $xfer += $elem649->read($input);
- $this->success []= $elem649;
+ $elem665 = null;
+ $elem665 = new \metastore\Partition();
+ $xfer += $elem665->read($input);
+ $this->success []= $elem665;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -20393,9 +20877,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter650)
+ foreach ($this->success as $iter666)
            {
- $xfer += $iter650->write($output);
+ $xfer += $iter666->write($output);
            }
          }
          $output->writeListEnd();
@@ -20615,15 +21099,15 @@ class ThriftHiveMetastore_get_partitions_pspec_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size651 = 0;
- $_etype654 = 0;
- $xfer += $input->readListBegin($_etype654, $_size651);
- for ($_i655 = 0; $_i655 < $_size651; ++$_i655)
+ $_size667 = 0;
+ $_etype670 = 0;
+ $xfer += $input->readListBegin($_etype670, $_size667);
+ for ($_i671 = 0; $_i671 < $_size667; ++$_i671)
              {
- $elem656 = null;
- $elem656 = new \metastore\PartitionSpec();
- $xfer += $elem656->read($input);
- $this->success []= $elem656;
+ $elem672 = null;
+ $elem672 = new \metastore\PartitionSpec();
+ $xfer += $elem672->read($input);
+ $this->success []= $elem672;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -20667,9 +21151,9 @@ class ThriftHiveMetastore_get_partitions_pspec_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter657)
+ foreach ($this->success as $iter673)
            {
- $xfer += $iter657->write($output);
+ $xfer += $iter673->write($output);
            }
          }
          $output->writeListEnd();
@@ -20876,14 +21360,14 @@ class ThriftHiveMetastore_get_partition_names_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size658 = 0;
- $_etype661 = 0;
- $xfer += $input->readListBegin($_etype661, $_size658);
- for ($_i662 = 0; $_i662 < $_size658; ++$_i662)
+ $_size674 = 0;
+ $_etype677 = 0;
+ $xfer += $input->readListBegin($_etype677, $_size674);
+ for ($_i678 = 0; $_i678 < $_size674; ++$_i678)
              {
- $elem663 = null;
- $xfer += $input->readString($elem663);
- $this->success []= $elem663;
+ $elem679 = null;
+ $xfer += $input->readString($elem679);
+ $this->success []= $elem679;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -20919,9 +21403,9 @@ class ThriftHiveMetastore_get_partition_names_result {
        {
          $output->writeListBegin(TType::STRING, count($this->success));
          {
- foreach ($this->success as $iter664)
+ foreach ($this->success as $iter680)
            {
- $xfer += $output->writeString($iter664);
+ $xfer += $output->writeString($iter680);
            }
          }
          $output->writeListEnd();
@@ -21037,14 +21521,14 @@ class ThriftHiveMetastore_get_partitions_ps_args {
          case 3:
            if ($ftype == TType::LST) {
              $this->part_vals = array();
- $_size665 = 0;
- $_etype668 = 0;
- $xfer += $input->readListBegin($_etype668, $_size665);
- for ($_i669 = 0; $_i669 < $_size665; ++$_i669)
+ $_size681 = 0;
+ $_etype684 = 0;
+ $xfer += $input->readListBegin($_etype684, $_size681);
+ for ($_i685 = 0; $_i685 < $_size681; ++$_i685)
              {
- $elem670 = null;
- $xfer += $input->readString($elem670);
- $this->part_vals []= $elem670;
+ $elem686 = null;
+ $xfer += $input->readString($elem686);
+ $this->part_vals []= $elem686;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -21089,9 +21573,9 @@ class ThriftHiveMetastore_get_partitions_ps_args {
        {
          $output->writeListBegin(TType::STRING, count($this->part_vals));
          {
- foreach ($this->part_vals as $iter671)
+ foreach ($this->part_vals as $iter687)
            {
- $xfer += $output->writeString($iter671);
+ $xfer += $output->writeString($iter687);
            }
          }
          $output->writeListEnd();
@@ -21185,15 +21669,15 @@ class ThriftHiveMetastore_get_partitions_ps_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size672 = 0;
- $_etype675 = 0;
- $xfer += $input->readListBegin($_etype675, $_size672);
- for ($_i676 = 0; $_i676 < $_size672; ++$_i676)
+ $_size688 = 0;
+ $_etype691 = 0;
+ $xfer += $input->readListBegin($_etype691, $_size688);
+ for ($_i692 = 0; $_i692 < $_size688; ++$_i692)
              {
- $elem677 = null;
- $elem677 = new \metastore\Partition();
- $xfer += $elem677->read($input);
- $this->success []= $elem677;
+ $elem693 = null;
+ $elem693 = new \metastore\Partition();
+ $xfer += $elem693->read($input);
+ $this->success []= $elem693;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -21237,9 +21721,9 @@ class ThriftHiveMetastore_get_partitions_ps_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter678)
+ foreach ($this->success as $iter694)
            {
- $xfer += $iter678->write($output);
+ $xfer += $iter694->write($output);
            }
          }
          $output->writeListEnd();
@@ -21386,14 +21870,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args {
          case 3:
            if ($ftype == TType::LST) {
              $this->part_vals = array();
- $_size679 = 0;
- $_etype682 = 0;
- $xfer += $input->readListBegin($_etype682, $_size679);
- for ($_i683 = 0; $_i683 < $_size679; ++$_i683)
+ $_size695 = 0;
+ $_etype698 = 0;
+ $xfer += $input->readListBegin($_etype698, $_size695);
+ for ($_i699 = 0; $_i699 < $_size695; ++$_i699)
              {
- $elem684 = null;
- $xfer += $input->readString($elem684);
- $this->part_vals []= $elem684;
+ $elem700 = null;
+ $xfer += $input->readString($elem700);
+ $this->part_vals []= $elem700;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -21417,14 +21901,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args {
          case 6:
            if ($ftype == TType::LST) {
              $this->group_names = array();
- $_size685 = 0;
- $_etype688 = 0;
- $xfer += $input->readListBegin($_etype688, $_size685);
- for ($_i689 = 0; $_i689 < $_size685; ++$_i689)
+ $_size701 = 0;
+ $_etype704 = 0;
+ $xfer += $input->readListBegin($_etype704, $_size701);
+ for ($_i705 = 0; $_i705 < $_size701; ++$_i705)
              {
- $elem690 = null;
- $xfer += $input->readString($elem690);
- $this->group_names []= $elem690;
+ $elem706 = null;
+ $xfer += $input->readString($elem706);
+ $this->group_names []= $elem706;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -21462,9 +21946,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args {
        {
          $output->writeListBegin(TType::STRING, count($this->part_vals));
          {
- foreach ($this->part_vals as $iter691)
+ foreach ($this->part_vals as $iter707)
            {
- $xfer += $output->writeString($iter691);
+ $xfer += $output->writeString($iter707);
            }
          }
          $output->writeListEnd();
@@ -21489,9 +21973,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args {
        {
          $output->writeListBegin(TType::STRING, count($this->group_names));
          {
- foreach ($this->group_names as $iter692)
+ foreach ($this->group_names as $iter708)
            {
- $xfer += $output->writeString($iter692);
+ $xfer += $output->writeString($iter708);
            }
          }
          $output->writeListEnd();
@@ -21580,15 +22064,15 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size693 = 0;
- $_etype696 = 0;
- $xfer += $input->readListBegin($_etype696, $_size693);
- for ($_i697 = 0; $_i697 < $_size693; ++$_i697)
+ $_size709 = 0;
+ $_etype712 = 0;
+ $xfer += $input->readListBegin($_etype712, $_size709);
+ for ($_i713 = 0; $_i713 < $_size709; ++$_i713)
              {
- $elem698 = null;
- $elem698 = new \metastore\Partition();
- $xfer += $elem698->read($input);
- $this->success []= $elem698;
+ $elem714 = null;
+ $elem714 = new \metastore\Partition();
+ $xfer += $elem714->read($input);
+ $this->success []= $elem714;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -21632,9 +22116,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter699)
+ foreach ($this->success as $iter715)
            {
- $xfer += $iter699->write($output);
+ $xfer += $iter715->write($output);
            }
          }
          $output->writeListEnd();
@@ -21755,14 +22239,14 @@ class ThriftHiveMetastore_get_partition_names_ps_args {
          case 3:
            if ($ftype == TType::LST) {
              $this->part_vals = array();
- $_size700 = 0;
- $_etype703 = 0;
- $xfer += $input->readListBegin($_etype703, $_size700);
- for ($_i704 = 0; $_i704 < $_size700; ++$_i704)
+ $_size716 = 0;
+ $_etype719 = 0;
+ $xfer += $input->readListBegin($_etype719, $_size716);
+ for ($_i720 = 0; $_i720 < $_size716; ++$_i720)
              {
- $elem705 = null;
- $xfer += $input->readString($elem705);
- $this->part_vals []= $elem705;
+ $elem721 = null;
+ $xfer += $input->readString($elem721);
+ $this->part_vals []= $elem721;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -21807,9 +22291,9 @@ class ThriftHiveMetastore_get_partition_names_ps_args {
        {
          $output->writeListBegin(TType::STRING, count($this->part_vals));
          {
- foreach ($this->part_vals as $iter706)
+ foreach ($this->part_vals as $iter722)
            {
- $xfer += $output->writeString($iter706);
+ $xfer += $output->writeString($iter722);
            }
          }
          $output->writeListEnd();
@@ -21902,14 +22386,14 @@ class ThriftHiveMetastore_get_partition_names_ps_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size707 = 0;
- $_etype710 = 0;
- $xfer += $input->readListBegin($_etype710, $_size707);
- for ($_i711 = 0; $_i711 < $_size707; ++$_i711)
+ $_size723 = 0;
+ $_etype726 = 0;
+ $xfer += $input->readListBegin($_etype726, $_size723);
+ for ($_i727 = 0; $_i727 < $_size723; ++$_i727)
              {
- $elem712 = null;
- $xfer += $input->readString($elem712);
- $this->success []= $elem712;
+ $elem728 = null;
+ $xfer += $input->readString($elem728);
+ $this->success []= $elem728;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -21953,9 +22437,9 @@ class ThriftHiveMetastore_get_partition_names_ps_result {
        {
          $output->writeListBegin(TType::STRING, count($this->success));
          {
- foreach ($this->success as $iter713)
+ foreach ($this->success as $iter729)
            {
- $xfer += $output->writeString($iter713);
+ $xfer += $output->writeString($iter729);
            }
          }
          $output->writeListEnd();
@@ -22198,15 +22682,15 @@ class ThriftHiveMetastore_get_partitions_by_filter_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size714 = 0;
- $_etype717 = 0;
- $xfer += $input->readListBegin($_etype717, $_size714);
- for ($_i718 = 0; $_i718 < $_size714; ++$_i718)
+ $_size730 = 0;
+ $_etype733 = 0;
+ $xfer += $input->readListBegin($_etype733, $_size730);
+ for ($_i734 = 0; $_i734 < $_size730; ++$_i734)
              {
- $elem719 = null;
- $elem719 = new \metastore\Partition();
- $xfer += $elem719->read($input);
- $this->success []= $elem719;
+ $elem735 = null;
+ $elem735 = new \metastore\Partition();
+ $xfer += $elem735->read($input);
+ $this->success []= $elem735;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -22250,9 +22734,9 @@ class ThriftHiveMetastore_get_partitions_by_filter_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter720)
+ foreach ($this->success as $iter736)
            {
- $xfer += $iter720->write($output);
+ $xfer += $iter736->write($output);
            }
          }
          $output->writeListEnd();
@@ -22495,15 +22979,15 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size721 = 0;
- $_etype724 = 0;
- $xfer += $input->readListBegin($_etype724, $_size721);
- for ($_i725 = 0; $_i725 < $_size721; ++$_i725)
+ $_size737 = 0;
+ $_etype740 = 0;
+ $xfer += $input->readListBegin($_etype740, $_size737);
+ for ($_i741 = 0; $_i741 < $_size737; ++$_i741)
              {
- $elem726 = null;
- $elem726 = new \metastore\PartitionSpec();
- $xfer += $elem726->read($input);
- $this->success []= $elem726;
+ $elem742 = null;
+ $elem742 = new \metastore\PartitionSpec();
+ $xfer += $elem742->read($input);
+ $this->success []= $elem742;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -22547,9 +23031,9 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter727)
+ foreach ($this->success as $iter743)
            {
- $xfer += $iter727->write($output);
+ $xfer += $iter743->write($output);
            }
          }
          $output->writeListEnd();
@@ -22869,14 +23353,14 @@ class ThriftHiveMetastore_get_partitions_by_names_args {
          case 3:
            if ($ftype == TType::LST) {
              $this->names = array();
- $_size728 = 0;
- $_etype731 = 0;
- $xfer += $input->readListBegin($_etype731, $_size728);
- for ($_i732 = 0; $_i732 < $_size728; ++$_i732)
+ $_size744 = 0;
+ $_etype747 = 0;
+ $xfer += $input->readListBegin($_etype747, $_size744);
+ for ($_i748 = 0; $_i748 < $_size744; ++$_i748)
              {
- $elem733 = null;
- $xfer += $input->readString($elem733);
- $this->names []= $elem733;
+ $elem749 = null;
+ $xfer += $input->readString($elem749);
+ $this->names []= $elem749;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -22914,9 +23398,9 @@ class ThriftHiveMetastore_get_partitions_by_names_args {
        {
          $output->writeListBegin(TType::STRING, count($this->names));
          {
- foreach ($this->names as $iter734)
+ foreach ($this->names as $iter750)
            {
- $xfer += $output->writeString($iter734);
+ $xfer += $output->writeString($iter750);
            }
          }
          $output->writeListEnd();
@@ -23005,15 +23489,15 @@ class ThriftHiveMetastore_get_partitions_by_names_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size735 = 0;
- $_etype738 = 0;
- $xfer += $input->readListBegin($_etype738, $_size735);
- for ($_i739 = 0; $_i739 < $_size735; ++$_i739)
+ $_size751 = 0;
+ $_etype754 = 0;
+ $xfer += $input->readListBegin($_etype754, $_size751);
+ for ($_i755 = 0; $_i755 < $_size751; ++$_i755)
              {
- $elem740 = null;
- $elem740 = new \metastore\Partition();
- $xfer += $elem740->read($input);
- $this->success []= $elem740;
+ $elem756 = null;
+ $elem756 = new \metastore\Partition();
+ $xfer += $elem756->read($input);
+ $this->success []= $elem756;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -23057,9 +23541,9 @@ class ThriftHiveMetastore_get_partitions_by_names_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter741)
+ foreach ($this->success as $iter757)
            {
- $xfer += $iter741->write($output);
+ $xfer += $iter757->write($output);
            }
          }
          $output->writeListEnd();
@@ -23398,15 +23882,15 @@ class ThriftHiveMetastore_alter_partitions_args {
          case 3:
            if ($ftype == TType::LST) {
              $this->new_parts = array();
- $_size742 = 0;
- $_etype745 = 0;
- $xfer += $input->readListBegin($_etype745, $_size742);
- for ($_i746 = 0; $_i746 < $_size742; ++$_i746)
+ $_size758 = 0;
+ $_etype761 = 0;
+ $xfer += $input->readListBegin($_etype761, $_size758);
+ for ($_i762 = 0; $_i762 < $_size758; ++$_i762)
              {
- $elem747 = null;
- $elem747 = new \metastore\Partition();
- $xfer += $elem747->read($input);
- $this->new_parts []= $elem747;
+ $elem763 = null;
+ $elem763 = new \metastore\Partition();
+ $xfer += $elem763->read($input);
+ $this->new_parts []= $elem763;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -23444,9 +23928,9 @@ class ThriftHiveMetastore_alter_partitions_args {
        {
          $output->writeListBegin(TType::STRUCT, count($this->new_parts));
          {
- foreach ($this->new_parts as $iter748)
+ foreach ($this->new_parts as $iter764)
            {
- $xfer += $iter748->write($output);
+ $xfer += $iter764->write($output);
            }
          }
          $output->writeListEnd();
@@ -23916,14 +24400,14 @@ class ThriftHiveMetastore_rename_partition_args {
          case 3:
            if ($ftype == TType::LST) {
              $this->part_vals = array();
- $_size749 = 0;
- $_etype752 = 0;
- $xfer += $input->readListBegin($_etype752, $_size749);
- for ($_i753 = 0; $_i753 < $_size749; ++$_i753)
+ $_size765 = 0;
+ $_etype768 = 0;
+ $xfer += $input->readListBegin($_etype768, $_size765);
+ for ($_i769 = 0; $_i769 < $_size765; ++$_i769)
              {
- $elem754 = null;
- $xfer += $input->readString($elem754);
- $this->part_vals []= $elem754;
+ $elem770 = null;
+ $xfer += $input->readString($elem770);
+ $this->part_vals []= $elem770;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -23969,9 +24453,9 @@ class ThriftHiveMetastore_rename_partition_args {
        {
          $output->writeListBegin(TType::STRING, count($this->part_vals));
          {
- foreach ($this->part_vals as $iter755)
+ foreach ($this->part_vals as $iter771)
            {
- $xfer += $output->writeString($iter755);
+ $xfer += $output->writeString($iter771);
            }
          }
          $output->writeListEnd();
@@ -24156,14 +24640,14 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args {
          case 1:
            if ($ftype == TType::LST) {
              $this->part_vals = array();
- $_size756 = 0;
- $_etype759 = 0;
- $xfer += $input->readListBegin($_etype759, $_size756);
- for ($_i760 = 0; $_i760 < $_size756; ++$_i760)
+ $_size772 = 0;
+ $_etype775 = 0;
+ $xfer += $input->readListBegin($_etype775, $_size772);
+ for ($_i776 = 0; $_i776 < $_size772; ++$_i776)
              {
- $elem761 = null;
- $xfer += $input->readString($elem761);
- $this->part_vals []= $elem761;
+ $elem777 = null;
+ $xfer += $input->readString($elem777);
+ $this->part_vals []= $elem777;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -24198,9 +24682,9 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args {
        {
          $output->writeListBegin(TType::STRING, count($this->part_vals));
          {
- foreach ($this->part_vals as $iter762)
+ foreach ($this->part_vals as $iter778)
            {
- $xfer += $output->writeString($iter762);
+ $xfer += $output->writeString($iter778);
            }
          }
          $output->writeListEnd();
@@ -24654,14 +25138,14 @@ class ThriftHiveMetastore_partition_name_to_vals_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size763 = 0;
- $_etype766 = 0;
- $xfer += $input->readListBegin($_etype766, $_size763);
- for ($_i767 = 0; $_i767 < $_size763; ++$_i767)
+ $_size779 = 0;
+ $_etype782 = 0;
+ $xfer += $input->readListBegin($_etype782, $_size779);
+ for ($_i783 = 0; $_i783 < $_size779; ++$_i783)
              {
- $elem768 = null;
- $xfer += $input->readString($elem768);
- $this->success []= $elem768;
+ $elem784 = null;
+ $xfer += $input->readString($elem784);
+ $this->success []= $elem784;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -24697,9 +25181,9 @@ class ThriftHiveMetastore_partition_name_to_vals_result {
        {
          $output->writeListBegin(TType::STRING, count($this->success));
          {
- foreach ($this->success as $iter769)
+ foreach ($this->success as $iter785)
            {
- $xfer += $output->writeString($iter769);
+ $xfer += $output->writeString($iter785);
            }
          }
          $output->writeListEnd();
@@ -24859,17 +25343,17 @@ class ThriftHiveMetastore_partition_name_to_spec_result {
          case 0:
            if ($ftype == TType::MAP) {
              $this->success = array();
- $_size770 = 0;
- $_ktype771 = 0;
- $_vtype772 = 0;
- $xfer += $input->readMapBegin($_ktype771, $_vtype772, $_size770);
- for ($_i774 = 0; $_i774 < $_size770; ++$_i774)
+ $_size786 = 0;
+ $_ktype787 = 0;
+ $_vtype788 = 0;
+ $xfer += $input->readMapBegin($_ktype787, $_vtype788, $_size786);
+ for ($_i790 = 0; $_i790 < $_size786; ++$_i790)
              {
- $key775 = '';
- $val776 = '';
- $xfer += $input->readString($key775);
- $xfer += $input->readString($val776);
- $this->success[$key775] = $val776;
+ $key791 = '';
+ $val792 = '';
+ $xfer += $input->readString($key791);
+ $xfer += $input->readString($val792);
+ $this->success[$key791] = $val792;
              }
              $xfer += $input->readMapEnd();
            } else {
@@ -24905,10 +25389,10 @@ class ThriftHiveMetastore_partition_name_to_spec_result {
        {
          $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success));
          {
- foreach ($this->success as $kiter777 => $viter778)
+ foreach ($this->success as $kiter793 => $viter794)
            {
- $xfer += $output->writeString($kiter777);
- $xfer += $output->writeString($viter778);
+ $xfer += $output->writeString($kiter793);
+ $xfer += $output->writeString($viter794);
            }
          }
          $output->writeMapEnd();
@@ -25028,17 +25512,17 @@ class ThriftHiveMetastore_markPartitionForEvent_args {
          case 3:
            if ($ftype == TType::MAP) {
              $this->part_vals = array();
- $_size779 = 0;
- $_ktype780 = 0;
- $_vtype781 = 0;
- $xfer += $input->readMapBegin($_ktype780, $_vtype781, $_size779);
- for ($_i783 = 0; $_i783 < $_size779; ++$_i783)
+ $_size795 = 0;
+ $_ktype796 = 0;
+ $_vtype797 = 0;
+ $xfer += $input->readMapBegin($_ktype796, $_vtype797, $_size795);
+ for ($_i799 = 0; $_i799 < $_size795; ++$_i799)
              {
- $key784 = '';
- $val785 = '';
- $xfer += $input->readString($key784);
- $xfer += $input->readString($val785);
- $this->part_vals[$key784] = $val785;
+ $key800 = '';
+ $val801 = '';
+ $xfer += $input->readString($key800);
+ $xfer += $input->readString($val801);
+ $this->part_vals[$key800] = $val801;
              }
              $xfer += $input->readMapEnd();
            } else {
@@ -25083,10 +25567,10 @@ class ThriftHiveMetastore_markPartitionForEvent_args {
        {
          $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals));
          {
- foreach ($this->part_vals as $kiter786 => $viter787)
+ foreach ($this->part_vals as $kiter802 => $viter803)
            {
- $xfer += $output->writeString($kiter786);
- $xfer += $output->writeString($viter787);
+ $xfer += $output->writeString($kiter802);
+ $xfer += $output->writeString($viter803);
            }
          }
          $output->writeMapEnd();
@@ -25408,17 +25892,17 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args {
          case 3:
            if ($ftype == TType::MAP) {
              $this->part_vals = array();
- $_size788 = 0;
- $_ktype789 = 0;
- $_vtype790 = 0;
- $xfer += $input->readMapBegin($_ktype789, $_vtype790, $_size788);
- for ($_i792 = 0; $_i792 < $_size788; ++$_i792)
+ $_size804 = 0;
+ $_ktype805 = 0;
+ $_vtype806 = 0;
+ $xfer += $input->readMapBegin($_ktype805, $_vtype806, $_size804);
+ for ($_i808 = 0; $_i808 < $_size804; ++$_i808)
              {
- $key793 = '';
- $val794 = '';
- $xfer += $input->readString($key793);
- $xfer += $input->readString($val794);
- $this->part_vals[$key793] = $val794;
+ $key809 = '';
+ $val810 = '';
+ $xfer += $input->readString($key809);
+ $xfer += $input->readString($val810);
+ $this->part_vals[$key809] = $val810;
              }
              $xfer += $input->readMapEnd();
            } else {
@@ -25463,10 +25947,10 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args {
        {
          $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals));
          {
- foreach ($this->part_vals as $kiter795 => $viter796)
+ foreach ($this->part_vals as $kiter811 => $viter812)
            {
- $xfer += $output->writeString($kiter795);
- $xfer += $output->writeString($viter796);
+ $xfer += $output->writeString($kiter811);
+ $xfer += $output->writeString($viter812);
            }
          }
          $output->writeMapEnd();
@@ -26940,15 +27424,15 @@ class ThriftHiveMetastore_get_indexes_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size797 = 0;
- $_etype800 = 0;
- $xfer += $input->readListBegin($_etype800, $_size797);
- for ($_i801 = 0; $_i801 < $_size797; ++$_i801)
+ $_size813 = 0;
+ $_etype816 = 0;
+ $xfer += $input->readListBegin($_etype816, $_size813);
+ for ($_i817 = 0; $_i817 < $_size813; ++$_i817)
              {
- $elem802 = null;
- $elem802 = new \metastore\Index();
- $xfer += $elem802->read($input);
- $this->success []= $elem802;
+ $elem818 = null;
+ $elem818 = new \metastore\Index();
+ $xfer += $elem818->read($input);
+ $this->success []= $elem818;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -26992,9 +27476,9 @@ class ThriftHiveMetastore_get_indexes_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter803)
+ foreach ($this->success as $iter819)
            {
- $xfer += $iter803->write($output);
+ $xfer += $iter819->write($output);
            }
          }
          $output->writeListEnd();
@@ -27201,14 +27685,14 @@ class ThriftHiveMetastore_get_index_names_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size804 = 0;
- $_etype807 = 0;
- $xfer += $input->readListBegin($_etype807, $_size804);
- for ($_i808 = 0; $_i808 < $_size804; ++$_i808)
+ $_size820 = 0;
+ $_etype823 = 0;
+ $xfer += $input->readListBegin($_etype823, $_size820);
+ for ($_i824 = 0; $_i824 < $_size820; ++$_i824)
              {
- $elem809 = null;
- $xfer += $input->readString($elem809);
- $this->success []= $elem809;
+ $elem825 = null;
+ $xfer += $input->readString($elem825);
+ $this->success []= $elem825;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -27244,9 +27728,9 @@ class ThriftHiveMetastore_get_index_names_result {
        {
          $output->writeListBegin(TType::STRING, count($this->success));
          {
- foreach ($this->success as $iter810)
+ foreach ($this->success as $iter826)
            {
- $xfer += $output->writeString($iter810);
+ $xfer += $output->writeString($iter826);
            }
          }
          $output->writeListEnd();
@@ -30720,14 +31204,14 @@ class ThriftHiveMetastore_get_functions_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size811 = 0;
- $_etype814 = 0;
- $xfer += $input->readListBegin($_etype814, $_size811);
- for ($_i815 = 0; $_i815 < $_size811; ++$_i815)
+ $_size827 = 0;
+ $_etype830 = 0;
+ $xfer += $input->readListBegin($_etype830, $_size827);
+ for ($_i831 = 0; $_i831 < $_size827; ++$_i831)
              {
- $elem816 = null;
- $xfer += $input->readString($elem816);
- $this->success []= $elem816;
+ $elem832 = null;
+ $xfer += $input->readString($elem832);
+ $this->success []= $elem832;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -30763,9 +31247,9 @@ class ThriftHiveMetastore_get_functions_result {
        {
          $output->writeListBegin(TType::STRING, count($this->success));
          {
- foreach ($this->success as $iter817)
+ foreach ($this->success as $iter833)
            {
- $xfer += $output->writeString($iter817);
+ $xfer += $output->writeString($iter833);
            }
          }
          $output->writeListEnd();
@@ -31634,14 +32118,14 @@ class ThriftHiveMetastore_get_role_names_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size818 = 0;
- $_etype821 = 0;
- $xfer += $input->readListBegin($_etype821, $_size818);
- for ($_i822 = 0; $_i822 < $_size818; ++$_i822)
+ $_size834 = 0;
+ $_etype837 = 0;
+ $xfer += $input->readListBegin($_etype837, $_size834);
+ for ($_i838 = 0; $_i838 < $_size834; ++$_i838)
              {
- $elem823 = null;
- $xfer += $input->readString($elem823);
- $this->success []= $elem823;
+ $elem839 = null;
+ $xfer += $input->readString($elem839);
+ $this->success []= $elem839;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -31677,9 +32161,9 @@ class ThriftHiveMetastore_get_role_names_result {
        {
          $output->writeListBegin(TType::STRING, count($this->success));
          {
- foreach ($this->success as $iter824)
+ foreach ($this->success as $iter840)
            {
- $xfer += $output->writeString($iter824);
+ $xfer += $output->writeString($iter840);
            }
          }
          $output->writeListEnd();
@@ -32370,15 +32854,15 @@ class ThriftHiveMetastore_list_roles_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size825 = 0;
- $_etype828 = 0;
- $xfer += $input->readListBegin($_etype828, $_size825);
- for ($_i829 = 0; $_i829 < $_size825; ++$_i829)
+ $_size841 = 0;
+ $_etype844 = 0;
+ $xfer += $input->readListBegin($_etype844, $_size841);
+ for ($_i845 = 0; $_i845 < $_size841; ++$_i845)
              {
- $elem830 = null;
- $elem830 = new \metastore\Role();
- $xfer += $elem830->read($input);
- $this->success []= $elem830;
+ $elem846 = null;
+ $elem846 = new \metastore\Role();
+ $xfer += $elem846->read($input);
+ $this->success []= $elem846;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -32414,9 +32898,9 @@ class ThriftHiveMetastore_list_roles_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter831)
+ foreach ($this->success as $iter847)
            {
- $xfer += $iter831->write($output);
+ $xfer += $iter847->write($output);
            }
          }
          $output->writeListEnd();
@@ -33078,14 +33562,14 @@ class ThriftHiveMetastore_get_privilege_set_args {
          case 3:
            if ($ftype == TType::LST) {
              $this->group_names = array();
- $_size832 = 0;
- $_etype835 = 0;
- $xfer += $input->readListBegin($_etype835, $_size832);
- for ($_i836 = 0; $_i836 < $_size832; ++$_i836)
+ $_size848 = 0;
+ $_etype851 = 0;
+ $xfer += $input->readListBegin($_etype851, $_size848);
+ for ($_i852 = 0; $_i852 < $_size848; ++$_i852)
              {
- $elem837 = null;
- $xfer += $input->readString($elem837);
- $this->group_names []= $elem837;
+ $elem853 = null;
+ $xfer += $input->readString($elem853);
+ $this->group_names []= $elem853;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -33126,9 +33610,9 @@ class ThriftHiveMetastore_get_privilege_set_args {
        {
          $output->writeListBegin(TType::STRING, count($this->group_names));
          {
- foreach ($this->group_names as $iter838)
+ foreach ($this->group_names as $iter854)
            {
- $xfer += $output->writeString($iter838);
+ $xfer += $output->writeString($iter854);
            }
          }
          $output->writeListEnd();
@@ -33436,15 +33920,15 @@ class ThriftHiveMetastore_list_privileges_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size839 = 0;
- $_etype842 = 0;
- $xfer += $input->readListBegin($_etype842, $_size839);
- for ($_i843 = 0; $_i843 < $_size839; ++$_i843)
+ $_size855 = 0;
+ $_etype858 = 0;
+ $xfer += $input->readListBegin($_etype858, $_size855);
+ for ($_i859 = 0; $_i859 < $_size855; ++$_i859)
              {
- $elem844 = null;
- $elem844 = new \metastore\HiveObjectPrivilege();
- $xfer += $elem844->read($input);
- $this->success []= $elem844;
+ $elem860 = null;
+ $elem860 = new \metastore\HiveObjectPrivilege();
+ $xfer += $elem860->read($input);
+ $this->success []= $elem860;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -33480,9 +33964,9 @@ class ThriftHiveMetastore_list_privileges_result {
        {
          $output->writeListBegin(TType::STRUCT, count($this->success));
          {
- foreach ($this->success as $iter845)
+ foreach ($this->success as $iter861)
            {
- $xfer += $iter845->write($output);
+ $xfer += $iter861->write($output);
            }
          }
          $output->writeListEnd();
@@ -34114,14 +34598,14 @@ class ThriftHiveMetastore_set_ugi_args {
          case 2:
            if ($ftype == TType::LST) {
              $this->group_names = array();
- $_size846 = 0;
- $_etype849 = 0;
- $xfer += $input->readListBegin($_etype849, $_size846);
- for ($_i850 = 0; $_i850 < $_size846; ++$_i850)
+ $_size862 = 0;
+ $_etype865 = 0;
+ $xfer += $input->readListBegin($_etype865, $_size862);
+ for ($_i866 = 0; $_i866 < $_size862; ++$_i866)
              {
- $elem851 = null;
- $xfer += $input->readString($elem851);
- $this->group_names []= $elem851;
+ $elem867 = null;
+ $xfer += $input->readString($elem867);
+ $this->group_names []= $elem867;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -34154,9 +34638,9 @@ class ThriftHiveMetastore_set_ugi_args {
        {
          $output->writeListBegin(TType::STRING, count($this->group_names));
          {
- foreach ($this->group_names as $iter852)
+ foreach ($this->group_names as $iter868)
            {
- $xfer += $output->writeString($iter852);
+ $xfer += $output->writeString($iter868);
            }
          }
          $output->writeListEnd();
@@ -34232,14 +34716,14 @@ class ThriftHiveMetastore_set_ugi_result {
          case 0:
            if ($ftype == TType::LST) {
              $this->success = array();
- $_size853 = 0;
- $_etype856 = 0;
- $xfer += $input->readListBegin($_etype856, $_size853);
- for ($_i857 = 0; $_i857 < $_size853; ++$_i857)
+ $_size869 = 0;
+ $_etype872 = 0;
+ $xfer += $input->readListBegin($_etype872, $_size869);
+ for ($_i873 = 0; $_i873 < $_size869; ++$_i873)
              {
- $elem858 = null;
- $xfer += $input->readString($elem858);
- $this->success []= $elem858;
+ $elem874 = null;
+ $xfer += $input->readString($elem874);
+ $this->success []= $elem874;
              }
              $xfer += $input->readListEnd();
            } else {
@@ -34275,9 +34759,9 @@ class ThriftHiveMetastore_set_ugi_result {
        {
          $output->writeListBegin(TType::STRING, count($this->success));
          {
- foreach ($this->success as $iter859)
+ foreach ($this->success as $iter875)
            {
- $xfer += $output->writeString($iter859);
+ $xfer += $output->writeString($iter875);
            }
          }
          $output->writeListEnd();

http://git-wip-us.apache.org/repos/asf/hive/blob/96c9ee64/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote
index dc348ef..e6d3755 100755
--- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote
+++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote
@@ -68,6 +68,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help':
    print(' DropPartitionsResult drop_partitions_req(DropPartitionsRequest req)')
    print(' Partition get_partition(string db_name, string tbl_name, part_vals)')
    print(' Partition exchange_partition( partitionSpecs, string source_db, string source_table_name, string dest_db, string dest_table_name)')
+ print(' exchange_partitions( partitionSpecs, string source_db, string source_table_name, string dest_db, string dest_table_name)')
    print(' Partition get_partition_with_auth(string db_name, string tbl_name, part_vals, string user_name, group_names)')
    print(' Partition get_partition_by_name(string db_name, string tbl_name, string part_name)')
    print(' get_partitions(string db_name, string tbl_name, i16 max_parts)')
@@ -481,6 +482,12 @@ elif cmd == 'exchange_partition':
      sys.exit(1)
    pp.pprint(client.exchange_partition(eval(args[0]),args[1],args[2],args[3],args[4],))

+elif cmd == 'exchange_partitions':
+ if len(args) != 5:
+ print('exchange_partitions requires 5 args')
+ sys.exit(1)
+ pp.pprint(client.exchange_partitions(eval(args[0]),args[1],args[2],args[3],args[4],))
+
  elif cmd == 'get_partition_with_auth':
    if len(args) != 5:
      print('get_partition_with_auth requires 5 args')

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 5 of 6 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedJan 13, '16 at 3:03p
activeJan 13, '16 at 3:03p
posts6
users1
websitehive.apache.org

1 user in discussion

Aihuaxu: 6 posts

People

Translate

site design / logo © 2021 Grokbase