You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by jv...@apache.org on 2010/07/30 08:40:11 UTC
svn commit: r980659 [6/34] - in /hadoop/hive/trunk: ./
common/src/java/org/apache/hadoop/hive/common/
contrib/src/test/results/clientpositive/ metastore/if/ metastore/src/gen-cpp/
metastore/src/gen-javabean/org/apache/hadoop/hive/metastore/api/ metasto...
Modified: hadoop/hive/trunk/metastore/src/gen-php/ThriftHiveMetastore.php
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/metastore/src/gen-php/ThriftHiveMetastore.php?rev=980659&r1=980658&r2=980659&view=diff
==============================================================================
--- hadoop/hive/trunk/metastore/src/gen-php/ThriftHiveMetastore.php (original)
+++ hadoop/hive/trunk/metastore/src/gen-php/ThriftHiveMetastore.php Fri Jul 30 06:40:04 2010
@@ -40,6 +40,11 @@ interface ThriftHiveMetastoreIf extends
public function get_config_value($name, $defaultValue);
public function partition_name_to_vals($part_name);
public function partition_name_to_spec($part_name);
+ public function add_index($new_index, $index_table);
+ public function drop_index_by_name($db_name, $tbl_name, $index_name, $deleteData);
+ public function get_index_by_name($db_name, $tbl_name, $index_name);
+ public function get_indexes($db_name, $tbl_name, $max_indexes);
+ public function get_index_names($db_name, $tbl_name, $max_indexes);
}
class ThriftHiveMetastoreClient extends FacebookServiceClient implements ThriftHiveMetastoreIf {
@@ -1768,6 +1773,301 @@ class ThriftHiveMetastoreClient extends
throw new Exception("partition_name_to_spec failed: unknown result");
}
+ public function add_index($new_index, $index_table)
+ {
+ $this->send_add_index($new_index, $index_table);
+ return $this->recv_add_index();
+ }
+
+ public function send_add_index($new_index, $index_table)
+ {
+ $args = new metastore_ThriftHiveMetastore_add_index_args();
+ $args->new_index = $new_index;
+ $args->index_table = $index_table;
+ $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'add_index', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('add_index', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_add_index()
+ {
+ $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'metastore_ThriftHiveMetastore_add_index_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_add_index_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;
+ }
+ throw new Exception("add_index failed: unknown result");
+ }
+
+ public function drop_index_by_name($db_name, $tbl_name, $index_name, $deleteData)
+ {
+ $this->send_drop_index_by_name($db_name, $tbl_name, $index_name, $deleteData);
+ return $this->recv_drop_index_by_name();
+ }
+
+ public function send_drop_index_by_name($db_name, $tbl_name, $index_name, $deleteData)
+ {
+ $args = new metastore_ThriftHiveMetastore_drop_index_by_name_args();
+ $args->db_name = $db_name;
+ $args->tbl_name = $tbl_name;
+ $args->index_name = $index_name;
+ $args->deleteData = $deleteData;
+ $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'drop_index_by_name', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('drop_index_by_name', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_drop_index_by_name()
+ {
+ $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'metastore_ThriftHiveMetastore_drop_index_by_name_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_drop_index_by_name_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;
+ }
+ throw new Exception("drop_index_by_name failed: unknown result");
+ }
+
+ public function get_index_by_name($db_name, $tbl_name, $index_name)
+ {
+ $this->send_get_index_by_name($db_name, $tbl_name, $index_name);
+ return $this->recv_get_index_by_name();
+ }
+
+ public function send_get_index_by_name($db_name, $tbl_name, $index_name)
+ {
+ $args = new metastore_ThriftHiveMetastore_get_index_by_name_args();
+ $args->db_name = $db_name;
+ $args->tbl_name = $tbl_name;
+ $args->index_name = $index_name;
+ $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'get_index_by_name', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('get_index_by_name', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_get_index_by_name()
+ {
+ $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'metastore_ThriftHiveMetastore_get_index_by_name_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_get_index_by_name_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;
+ }
+ throw new Exception("get_index_by_name failed: unknown result");
+ }
+
+ public function get_indexes($db_name, $tbl_name, $max_indexes)
+ {
+ $this->send_get_indexes($db_name, $tbl_name, $max_indexes);
+ return $this->recv_get_indexes();
+ }
+
+ public function send_get_indexes($db_name, $tbl_name, $max_indexes)
+ {
+ $args = new metastore_ThriftHiveMetastore_get_indexes_args();
+ $args->db_name = $db_name;
+ $args->tbl_name = $tbl_name;
+ $args->max_indexes = $max_indexes;
+ $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'get_indexes', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('get_indexes', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_get_indexes()
+ {
+ $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'metastore_ThriftHiveMetastore_get_indexes_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_get_indexes_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;
+ }
+ throw new Exception("get_indexes failed: unknown result");
+ }
+
+ public function get_index_names($db_name, $tbl_name, $max_indexes)
+ {
+ $this->send_get_index_names($db_name, $tbl_name, $max_indexes);
+ return $this->recv_get_index_names();
+ }
+
+ public function send_get_index_names($db_name, $tbl_name, $max_indexes)
+ {
+ $args = new metastore_ThriftHiveMetastore_get_index_names_args();
+ $args->db_name = $db_name;
+ $args->tbl_name = $tbl_name;
+ $args->max_indexes = $max_indexes;
+ $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'get_index_names', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('get_index_names', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_get_index_names()
+ {
+ $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'metastore_ThriftHiveMetastore_get_index_names_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_get_index_names_result();
+ $result->read($this->input_);
+ $this->input_->readMessageEnd();
+ }
+ if ($result->success !== null) {
+ return $result->success;
+ }
+ if ($result->o2 !== null) {
+ throw $result->o2;
+ }
+ throw new Exception("get_index_names failed: unknown result");
+ }
+
}
// HELPER FUNCTIONS AND STRUCTURES
@@ -2445,14 +2745,14 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size101 = 0;
- $_etype104 = 0;
- $xfer += $input->readListBegin($_etype104, $_size101);
- for ($_i105 = 0; $_i105 < $_size101; ++$_i105)
+ $_size103 = 0;
+ $_etype106 = 0;
+ $xfer += $input->readListBegin($_etype106, $_size103);
+ for ($_i107 = 0; $_i107 < $_size103; ++$_i107)
{
- $elem106 = null;
- $xfer += $input->readString($elem106);
- $this->success []= $elem106;
+ $elem108 = null;
+ $xfer += $input->readString($elem108);
+ $this->success []= $elem108;
}
$xfer += $input->readListEnd();
} else {
@@ -2488,9 +2788,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRING, count($this->success));
{
- foreach ($this->success as $iter107)
+ foreach ($this->success as $iter109)
{
- $xfer += $output->writeString($iter107);
+ $xfer += $output->writeString($iter109);
}
}
$output->writeListEnd();
@@ -3194,18 +3494,18 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::MAP) {
$this->success = array();
- $_size108 = 0;
- $_ktype109 = 0;
- $_vtype110 = 0;
- $xfer += $input->readMapBegin($_ktype109, $_vtype110, $_size108);
- for ($_i112 = 0; $_i112 < $_size108; ++$_i112)
+ $_size110 = 0;
+ $_ktype111 = 0;
+ $_vtype112 = 0;
+ $xfer += $input->readMapBegin($_ktype111, $_vtype112, $_size110);
+ for ($_i114 = 0; $_i114 < $_size110; ++$_i114)
{
- $key113 = '';
- $val114 = new metastore_Type();
- $xfer += $input->readString($key113);
- $val114 = new metastore_Type();
- $xfer += $val114->read($input);
- $this->success[$key113] = $val114;
+ $key115 = '';
+ $val116 = new metastore_Type();
+ $xfer += $input->readString($key115);
+ $val116 = new metastore_Type();
+ $xfer += $val116->read($input);
+ $this->success[$key115] = $val116;
}
$xfer += $input->readMapEnd();
} else {
@@ -3241,10 +3541,10 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeMapBegin(TType::STRING, TType::STRUCT, count($this->success));
{
- foreach ($this->success as $kiter115 => $viter116)
+ foreach ($this->success as $kiter117 => $viter118)
{
- $xfer += $output->writeString($kiter115);
- $xfer += $viter116->write($output);
+ $xfer += $output->writeString($kiter117);
+ $xfer += $viter118->write($output);
}
}
$output->writeMapEnd();
@@ -3430,15 +3730,15 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size117 = 0;
- $_etype120 = 0;
- $xfer += $input->readListBegin($_etype120, $_size117);
- for ($_i121 = 0; $_i121 < $_size117; ++$_i121)
+ $_size119 = 0;
+ $_etype122 = 0;
+ $xfer += $input->readListBegin($_etype122, $_size119);
+ for ($_i123 = 0; $_i123 < $_size119; ++$_i123)
{
- $elem122 = null;
- $elem122 = new metastore_FieldSchema();
- $xfer += $elem122->read($input);
- $this->success []= $elem122;
+ $elem124 = null;
+ $elem124 = new metastore_FieldSchema();
+ $xfer += $elem124->read($input);
+ $this->success []= $elem124;
}
$xfer += $input->readListEnd();
} else {
@@ -3490,9 +3790,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRUCT, count($this->success));
{
- foreach ($this->success as $iter123)
+ foreach ($this->success as $iter125)
{
- $xfer += $iter123->write($output);
+ $xfer += $iter125->write($output);
}
}
$output->writeListEnd();
@@ -3688,15 +3988,15 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size124 = 0;
- $_etype127 = 0;
- $xfer += $input->readListBegin($_etype127, $_size124);
- for ($_i128 = 0; $_i128 < $_size124; ++$_i128)
+ $_size126 = 0;
+ $_etype129 = 0;
+ $xfer += $input->readListBegin($_etype129, $_size126);
+ for ($_i130 = 0; $_i130 < $_size126; ++$_i130)
{
- $elem129 = null;
- $elem129 = new metastore_FieldSchema();
- $xfer += $elem129->read($input);
- $this->success []= $elem129;
+ $elem131 = null;
+ $elem131 = new metastore_FieldSchema();
+ $xfer += $elem131->read($input);
+ $this->success []= $elem131;
}
$xfer += $input->readListEnd();
} else {
@@ -3748,9 +4048,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRUCT, count($this->success));
{
- foreach ($this->success as $iter130)
+ foreach ($this->success as $iter132)
{
- $xfer += $iter130->write($output);
+ $xfer += $iter132->write($output);
}
}
$output->writeListEnd();
@@ -4352,14 +4652,14 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size131 = 0;
- $_etype134 = 0;
- $xfer += $input->readListBegin($_etype134, $_size131);
- for ($_i135 = 0; $_i135 < $_size131; ++$_i135)
+ $_size133 = 0;
+ $_etype136 = 0;
+ $xfer += $input->readListBegin($_etype136, $_size133);
+ for ($_i137 = 0; $_i137 < $_size133; ++$_i137)
{
- $elem136 = null;
- $xfer += $input->readString($elem136);
- $this->success []= $elem136;
+ $elem138 = null;
+ $xfer += $input->readString($elem138);
+ $this->success []= $elem138;
}
$xfer += $input->readListEnd();
} else {
@@ -4395,9 +4695,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRING, count($this->success));
{
- foreach ($this->success as $iter137)
+ foreach ($this->success as $iter139)
{
- $xfer += $output->writeString($iter137);
+ $xfer += $output->writeString($iter139);
}
}
$output->writeListEnd();
@@ -5139,14 +5439,14 @@ class metastore_ThriftHiveMetastore_appe
case 3:
if ($ftype == TType::LST) {
$this->part_vals = array();
- $_size138 = 0;
- $_etype141 = 0;
- $xfer += $input->readListBegin($_etype141, $_size138);
- for ($_i142 = 0; $_i142 < $_size138; ++$_i142)
+ $_size140 = 0;
+ $_etype143 = 0;
+ $xfer += $input->readListBegin($_etype143, $_size140);
+ for ($_i144 = 0; $_i144 < $_size140; ++$_i144)
{
- $elem143 = null;
- $xfer += $input->readString($elem143);
- $this->part_vals []= $elem143;
+ $elem145 = null;
+ $xfer += $input->readString($elem145);
+ $this->part_vals []= $elem145;
}
$xfer += $input->readListEnd();
} else {
@@ -5184,9 +5484,9 @@ class metastore_ThriftHiveMetastore_appe
{
$output->writeListBegin(TType::STRING, count($this->part_vals));
{
- foreach ($this->part_vals as $iter144)
+ foreach ($this->part_vals as $iter146)
{
- $xfer += $output->writeString($iter144);
+ $xfer += $output->writeString($iter146);
}
}
$output->writeListEnd();
@@ -5683,14 +5983,14 @@ class metastore_ThriftHiveMetastore_drop
case 3:
if ($ftype == TType::LST) {
$this->part_vals = array();
- $_size145 = 0;
- $_etype148 = 0;
- $xfer += $input->readListBegin($_etype148, $_size145);
- for ($_i149 = 0; $_i149 < $_size145; ++$_i149)
+ $_size147 = 0;
+ $_etype150 = 0;
+ $xfer += $input->readListBegin($_etype150, $_size147);
+ for ($_i151 = 0; $_i151 < $_size147; ++$_i151)
{
- $elem150 = null;
- $xfer += $input->readString($elem150);
- $this->part_vals []= $elem150;
+ $elem152 = null;
+ $xfer += $input->readString($elem152);
+ $this->part_vals []= $elem152;
}
$xfer += $input->readListEnd();
} else {
@@ -5735,9 +6035,9 @@ class metastore_ThriftHiveMetastore_drop
{
$output->writeListBegin(TType::STRING, count($this->part_vals));
{
- foreach ($this->part_vals as $iter151)
+ foreach ($this->part_vals as $iter153)
{
- $xfer += $output->writeString($iter151);
+ $xfer += $output->writeString($iter153);
}
}
$output->writeListEnd();
@@ -6197,14 +6497,14 @@ class metastore_ThriftHiveMetastore_get_
case 3:
if ($ftype == TType::LST) {
$this->part_vals = array();
- $_size152 = 0;
- $_etype155 = 0;
- $xfer += $input->readListBegin($_etype155, $_size152);
- for ($_i156 = 0; $_i156 < $_size152; ++$_i156)
+ $_size154 = 0;
+ $_etype157 = 0;
+ $xfer += $input->readListBegin($_etype157, $_size154);
+ for ($_i158 = 0; $_i158 < $_size154; ++$_i158)
{
- $elem157 = null;
- $xfer += $input->readString($elem157);
- $this->part_vals []= $elem157;
+ $elem159 = null;
+ $xfer += $input->readString($elem159);
+ $this->part_vals []= $elem159;
}
$xfer += $input->readListEnd();
} else {
@@ -6242,9 +6542,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRING, count($this->part_vals));
{
- foreach ($this->part_vals as $iter158)
+ foreach ($this->part_vals as $iter160)
{
- $xfer += $output->writeString($iter158);
+ $xfer += $output->writeString($iter160);
}
}
$output->writeListEnd();
@@ -6790,15 +7090,15 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size159 = 0;
- $_etype162 = 0;
- $xfer += $input->readListBegin($_etype162, $_size159);
- for ($_i163 = 0; $_i163 < $_size159; ++$_i163)
+ $_size161 = 0;
+ $_etype164 = 0;
+ $xfer += $input->readListBegin($_etype164, $_size161);
+ for ($_i165 = 0; $_i165 < $_size161; ++$_i165)
{
- $elem164 = null;
- $elem164 = new metastore_Partition();
- $xfer += $elem164->read($input);
- $this->success []= $elem164;
+ $elem166 = null;
+ $elem166 = new metastore_Partition();
+ $xfer += $elem166->read($input);
+ $this->success []= $elem166;
}
$xfer += $input->readListEnd();
} else {
@@ -6842,9 +7142,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRUCT, count($this->success));
{
- foreach ($this->success as $iter165)
+ foreach ($this->success as $iter167)
{
- $xfer += $iter165->write($output);
+ $xfer += $iter167->write($output);
}
}
$output->writeListEnd();
@@ -7036,14 +7336,14 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size166 = 0;
- $_etype169 = 0;
- $xfer += $input->readListBegin($_etype169, $_size166);
- for ($_i170 = 0; $_i170 < $_size166; ++$_i170)
+ $_size168 = 0;
+ $_etype171 = 0;
+ $xfer += $input->readListBegin($_etype171, $_size168);
+ for ($_i172 = 0; $_i172 < $_size168; ++$_i172)
{
- $elem171 = null;
- $xfer += $input->readString($elem171);
- $this->success []= $elem171;
+ $elem173 = null;
+ $xfer += $input->readString($elem173);
+ $this->success []= $elem173;
}
$xfer += $input->readListEnd();
} else {
@@ -7079,9 +7379,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRING, count($this->success));
{
- foreach ($this->success as $iter172)
+ foreach ($this->success as $iter174)
{
- $xfer += $output->writeString($iter172);
+ $xfer += $output->writeString($iter174);
}
}
$output->writeListEnd();
@@ -7185,14 +7485,14 @@ class metastore_ThriftHiveMetastore_get_
case 3:
if ($ftype == TType::LST) {
$this->part_vals = array();
- $_size173 = 0;
- $_etype176 = 0;
- $xfer += $input->readListBegin($_etype176, $_size173);
- for ($_i177 = 0; $_i177 < $_size173; ++$_i177)
+ $_size175 = 0;
+ $_etype178 = 0;
+ $xfer += $input->readListBegin($_etype178, $_size175);
+ for ($_i179 = 0; $_i179 < $_size175; ++$_i179)
{
- $elem178 = null;
- $xfer += $input->readString($elem178);
- $this->part_vals []= $elem178;
+ $elem180 = null;
+ $xfer += $input->readString($elem180);
+ $this->part_vals []= $elem180;
}
$xfer += $input->readListEnd();
} else {
@@ -7237,9 +7537,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRING, count($this->part_vals));
{
- foreach ($this->part_vals as $iter179)
+ foreach ($this->part_vals as $iter181)
{
- $xfer += $output->writeString($iter179);
+ $xfer += $output->writeString($iter181);
}
}
$output->writeListEnd();
@@ -7315,15 +7615,15 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size180 = 0;
- $_etype183 = 0;
- $xfer += $input->readListBegin($_etype183, $_size180);
- for ($_i184 = 0; $_i184 < $_size180; ++$_i184)
+ $_size182 = 0;
+ $_etype185 = 0;
+ $xfer += $input->readListBegin($_etype185, $_size182);
+ for ($_i186 = 0; $_i186 < $_size182; ++$_i186)
{
- $elem185 = null;
- $elem185 = new metastore_Partition();
- $xfer += $elem185->read($input);
- $this->success []= $elem185;
+ $elem187 = null;
+ $elem187 = new metastore_Partition();
+ $xfer += $elem187->read($input);
+ $this->success []= $elem187;
}
$xfer += $input->readListEnd();
} else {
@@ -7359,9 +7659,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRUCT, count($this->success));
{
- foreach ($this->success as $iter186)
+ foreach ($this->success as $iter188)
{
- $xfer += $iter186->write($output);
+ $xfer += $iter188->write($output);
}
}
$output->writeListEnd();
@@ -7465,14 +7765,14 @@ class metastore_ThriftHiveMetastore_get_
case 3:
if ($ftype == TType::LST) {
$this->part_vals = array();
- $_size187 = 0;
- $_etype190 = 0;
- $xfer += $input->readListBegin($_etype190, $_size187);
- for ($_i191 = 0; $_i191 < $_size187; ++$_i191)
+ $_size189 = 0;
+ $_etype192 = 0;
+ $xfer += $input->readListBegin($_etype192, $_size189);
+ for ($_i193 = 0; $_i193 < $_size189; ++$_i193)
{
- $elem192 = null;
- $xfer += $input->readString($elem192);
- $this->part_vals []= $elem192;
+ $elem194 = null;
+ $xfer += $input->readString($elem194);
+ $this->part_vals []= $elem194;
}
$xfer += $input->readListEnd();
} else {
@@ -7517,9 +7817,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRING, count($this->part_vals));
{
- foreach ($this->part_vals as $iter193)
+ foreach ($this->part_vals as $iter195)
{
- $xfer += $output->writeString($iter193);
+ $xfer += $output->writeString($iter195);
}
}
$output->writeListEnd();
@@ -7594,14 +7894,14 @@ class metastore_ThriftHiveMetastore_get_
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size194 = 0;
- $_etype197 = 0;
- $xfer += $input->readListBegin($_etype197, $_size194);
- for ($_i198 = 0; $_i198 < $_size194; ++$_i198)
+ $_size196 = 0;
+ $_etype199 = 0;
+ $xfer += $input->readListBegin($_etype199, $_size196);
+ for ($_i200 = 0; $_i200 < $_size196; ++$_i200)
{
- $elem199 = null;
- $xfer += $input->readString($elem199);
- $this->success []= $elem199;
+ $elem201 = null;
+ $xfer += $input->readString($elem201);
+ $this->success []= $elem201;
}
$xfer += $input->readListEnd();
} else {
@@ -7637,9 +7937,9 @@ class metastore_ThriftHiveMetastore_get_
{
$output->writeListBegin(TType::STRING, count($this->success));
{
- foreach ($this->success as $iter200)
+ foreach ($this->success as $iter202)
{
- $xfer += $output->writeString($iter200);
+ $xfer += $output->writeString($iter202);
}
}
$output->writeListEnd();
@@ -8185,14 +8485,14 @@ class metastore_ThriftHiveMetastore_part
case 0:
if ($ftype == TType::LST) {
$this->success = array();
- $_size201 = 0;
- $_etype204 = 0;
- $xfer += $input->readListBegin($_etype204, $_size201);
- for ($_i205 = 0; $_i205 < $_size201; ++$_i205)
+ $_size203 = 0;
+ $_etype206 = 0;
+ $xfer += $input->readListBegin($_etype206, $_size203);
+ for ($_i207 = 0; $_i207 < $_size203; ++$_i207)
{
- $elem206 = null;
- $xfer += $input->readString($elem206);
- $this->success []= $elem206;
+ $elem208 = null;
+ $xfer += $input->readString($elem208);
+ $this->success []= $elem208;
}
$xfer += $input->readListEnd();
} else {
@@ -8228,9 +8528,9 @@ class metastore_ThriftHiveMetastore_part
{
$output->writeListBegin(TType::STRING, count($this->success));
{
- foreach ($this->success as $iter207)
+ foreach ($this->success as $iter209)
{
- $xfer += $output->writeString($iter207);
+ $xfer += $output->writeString($iter209);
}
}
$output->writeListEnd();
@@ -8381,17 +8681,17 @@ class metastore_ThriftHiveMetastore_part
case 0:
if ($ftype == TType::MAP) {
$this->success = array();
- $_size208 = 0;
- $_ktype209 = 0;
- $_vtype210 = 0;
- $xfer += $input->readMapBegin($_ktype209, $_vtype210, $_size208);
- for ($_i212 = 0; $_i212 < $_size208; ++$_i212)
+ $_size210 = 0;
+ $_ktype211 = 0;
+ $_vtype212 = 0;
+ $xfer += $input->readMapBegin($_ktype211, $_vtype212, $_size210);
+ for ($_i214 = 0; $_i214 < $_size210; ++$_i214)
{
- $key213 = '';
- $val214 = '';
- $xfer += $input->readString($key213);
- $xfer += $input->readString($val214);
- $this->success[$key213] = $val214;
+ $key215 = '';
+ $val216 = '';
+ $xfer += $input->readString($key215);
+ $xfer += $input->readString($val216);
+ $this->success[$key215] = $val216;
}
$xfer += $input->readMapEnd();
} else {
@@ -8427,10 +8727,10 @@ class metastore_ThriftHiveMetastore_part
{
$output->writeMapBegin(TType::STRING, TType::STRING, count($this->success));
{
- foreach ($this->success as $kiter215 => $viter216)
+ foreach ($this->success as $kiter217 => $viter218)
{
- $xfer += $output->writeString($kiter215);
- $xfer += $output->writeString($viter216);
+ $xfer += $output->writeString($kiter217);
+ $xfer += $output->writeString($viter218);
}
}
$output->writeMapEnd();
@@ -8449,4 +8749,1218 @@ class metastore_ThriftHiveMetastore_part
}
+class metastore_ThriftHiveMetastore_add_index_args {
+ static $_TSPEC;
+
+ public $new_index = null;
+ public $index_table = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'new_index',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_Index',
+ ),
+ 2 => array(
+ 'var' => 'index_table',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_Table',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['new_index'])) {
+ $this->new_index = $vals['new_index'];
+ }
+ if (isset($vals['index_table'])) {
+ $this->index_table = $vals['index_table'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_add_index_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::STRUCT) {
+ $this->new_index = new metastore_Index();
+ $xfer += $this->new_index->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->index_table = new metastore_Table();
+ $xfer += $this->index_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('ThriftHiveMetastore_add_index_args');
+ if ($this->new_index !== null) {
+ if (!is_object($this->new_index)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('new_index', TType::STRUCT, 1);
+ $xfer += $this->new_index->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->index_table !== null) {
+ if (!is_object($this->index_table)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('index_table', TType::STRUCT, 2);
+ $xfer += $this->index_table->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_add_index_result {
+ static $_TSPEC;
+
+ public $success = null;
+ public $o1 = null;
+ public $o2 = null;
+ public $o3 = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_Index',
+ ),
+ 1 => array(
+ 'var' => 'o1',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_InvalidObjectException',
+ ),
+ 2 => array(
+ 'var' => 'o2',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_AlreadyExistsException',
+ ),
+ 3 => array(
+ 'var' => 'o3',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_MetaException',
+ ),
+ );
+ }
+ 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'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_add_index_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::STRUCT) {
+ $this->success = new metastore_Index();
+ $xfer += $this->success->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->o1 = new metastore_InvalidObjectException();
+ $xfer += $this->o1->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->o2 = new metastore_AlreadyExistsException();
+ $xfer += $this->o2->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRUCT) {
+ $this->o3 = new metastore_MetaException();
+ $xfer += $this->o3->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_add_index_result');
+ if ($this->success !== null) {
+ if (!is_object($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+ $xfer += $this->success->write($output);
+ $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();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_drop_index_by_name_args {
+ static $_TSPEC;
+
+ public $db_name = null;
+ public $tbl_name = null;
+ public $index_name = null;
+ public $deleteData = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'db_name',
+ 'type' => TType::STRING,
+ ),
+ 2 => array(
+ 'var' => 'tbl_name',
+ 'type' => TType::STRING,
+ ),
+ 3 => array(
+ 'var' => 'index_name',
+ 'type' => TType::STRING,
+ ),
+ 4 => array(
+ 'var' => 'deleteData',
+ 'type' => TType::BOOL,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['db_name'])) {
+ $this->db_name = $vals['db_name'];
+ }
+ if (isset($vals['tbl_name'])) {
+ $this->tbl_name = $vals['tbl_name'];
+ }
+ if (isset($vals['index_name'])) {
+ $this->index_name = $vals['index_name'];
+ }
+ if (isset($vals['deleteData'])) {
+ $this->deleteData = $vals['deleteData'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_drop_index_by_name_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::STRING) {
+ $xfer += $input->readString($this->db_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->tbl_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->index_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::BOOL) {
+ $xfer += $input->readBool($this->deleteData);
+ } 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_drop_index_by_name_args');
+ if ($this->db_name !== null) {
+ $xfer += $output->writeFieldBegin('db_name', TType::STRING, 1);
+ $xfer += $output->writeString($this->db_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->tbl_name !== null) {
+ $xfer += $output->writeFieldBegin('tbl_name', TType::STRING, 2);
+ $xfer += $output->writeString($this->tbl_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->index_name !== null) {
+ $xfer += $output->writeFieldBegin('index_name', TType::STRING, 3);
+ $xfer += $output->writeString($this->index_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->deleteData !== null) {
+ $xfer += $output->writeFieldBegin('deleteData', TType::BOOL, 4);
+ $xfer += $output->writeBool($this->deleteData);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_drop_index_by_name_result {
+ static $_TSPEC;
+
+ public $success = null;
+ public $o1 = null;
+ public $o2 = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::BOOL,
+ ),
+ 1 => array(
+ 'var' => 'o1',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_NoSuchObjectException',
+ ),
+ 2 => array(
+ 'var' => 'o2',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_MetaException',
+ ),
+ );
+ }
+ 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'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_drop_index_by_name_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::BOOL) {
+ $xfer += $input->readBool($this->success);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->o1 = new metastore_NoSuchObjectException();
+ $xfer += $this->o1->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->o2 = new metastore_MetaException();
+ $xfer += $this->o2->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_drop_index_by_name_result');
+ if ($this->success !== null) {
+ $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
+ $xfer += $output->writeBool($this->success);
+ $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();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_get_index_by_name_args {
+ static $_TSPEC;
+
+ public $db_name = null;
+ public $tbl_name = null;
+ public $index_name = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'db_name',
+ 'type' => TType::STRING,
+ ),
+ 2 => array(
+ 'var' => 'tbl_name',
+ 'type' => TType::STRING,
+ ),
+ 3 => array(
+ 'var' => 'index_name',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['db_name'])) {
+ $this->db_name = $vals['db_name'];
+ }
+ if (isset($vals['tbl_name'])) {
+ $this->tbl_name = $vals['tbl_name'];
+ }
+ if (isset($vals['index_name'])) {
+ $this->index_name = $vals['index_name'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_get_index_by_name_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::STRING) {
+ $xfer += $input->readString($this->db_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->tbl_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->index_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_get_index_by_name_args');
+ if ($this->db_name !== null) {
+ $xfer += $output->writeFieldBegin('db_name', TType::STRING, 1);
+ $xfer += $output->writeString($this->db_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->tbl_name !== null) {
+ $xfer += $output->writeFieldBegin('tbl_name', TType::STRING, 2);
+ $xfer += $output->writeString($this->tbl_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->index_name !== null) {
+ $xfer += $output->writeFieldBegin('index_name', TType::STRING, 3);
+ $xfer += $output->writeString($this->index_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_get_index_by_name_result {
+ static $_TSPEC;
+
+ public $success = null;
+ public $o1 = null;
+ public $o2 = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_Index',
+ ),
+ 1 => array(
+ 'var' => 'o1',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_MetaException',
+ ),
+ 2 => array(
+ 'var' => 'o2',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_NoSuchObjectException',
+ ),
+ );
+ }
+ 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'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_get_index_by_name_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::STRUCT) {
+ $this->success = new metastore_Index();
+ $xfer += $this->success->read($input);
+ } 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;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_index_by_name_result');
+ if ($this->success !== null) {
+ if (!is_object($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+ $xfer += $this->success->write($output);
+ $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();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_get_indexes_args {
+ static $_TSPEC;
+
+ public $db_name = null;
+ public $tbl_name = null;
+ public $max_indexes = -1;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'db_name',
+ 'type' => TType::STRING,
+ ),
+ 2 => array(
+ 'var' => 'tbl_name',
+ 'type' => TType::STRING,
+ ),
+ 3 => array(
+ 'var' => 'max_indexes',
+ 'type' => TType::I16,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['db_name'])) {
+ $this->db_name = $vals['db_name'];
+ }
+ if (isset($vals['tbl_name'])) {
+ $this->tbl_name = $vals['tbl_name'];
+ }
+ if (isset($vals['max_indexes'])) {
+ $this->max_indexes = $vals['max_indexes'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_get_indexes_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::STRING) {
+ $xfer += $input->readString($this->db_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->tbl_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::I16) {
+ $xfer += $input->readI16($this->max_indexes);
+ } 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_get_indexes_args');
+ if ($this->db_name !== null) {
+ $xfer += $output->writeFieldBegin('db_name', TType::STRING, 1);
+ $xfer += $output->writeString($this->db_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->tbl_name !== null) {
+ $xfer += $output->writeFieldBegin('tbl_name', TType::STRING, 2);
+ $xfer += $output->writeString($this->tbl_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->max_indexes !== null) {
+ $xfer += $output->writeFieldBegin('max_indexes', TType::I16, 3);
+ $xfer += $output->writeI16($this->max_indexes);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_get_indexes_result {
+ static $_TSPEC;
+
+ public $success = null;
+ public $o1 = null;
+ public $o2 = 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_Index',
+ ),
+ ),
+ 1 => array(
+ 'var' => 'o1',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_NoSuchObjectException',
+ ),
+ 2 => array(
+ 'var' => 'o2',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_MetaException',
+ ),
+ );
+ }
+ 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'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_get_indexes_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();
+ $_size219 = 0;
+ $_etype222 = 0;
+ $xfer += $input->readListBegin($_etype222, $_size219);
+ for ($_i223 = 0; $_i223 < $_size219; ++$_i223)
+ {
+ $elem224 = null;
+ $elem224 = new metastore_Index();
+ $xfer += $elem224->read($input);
+ $this->success []= $elem224;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->o1 = new metastore_NoSuchObjectException();
+ $xfer += $this->o1->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->o2 = new metastore_MetaException();
+ $xfer += $this->o2->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_get_indexes_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 $iter225)
+ {
+ $xfer += $iter225->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();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_get_index_names_args {
+ static $_TSPEC;
+
+ public $db_name = null;
+ public $tbl_name = null;
+ public $max_indexes = -1;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'db_name',
+ 'type' => TType::STRING,
+ ),
+ 2 => array(
+ 'var' => 'tbl_name',
+ 'type' => TType::STRING,
+ ),
+ 3 => array(
+ 'var' => 'max_indexes',
+ 'type' => TType::I16,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['db_name'])) {
+ $this->db_name = $vals['db_name'];
+ }
+ if (isset($vals['tbl_name'])) {
+ $this->tbl_name = $vals['tbl_name'];
+ }
+ if (isset($vals['max_indexes'])) {
+ $this->max_indexes = $vals['max_indexes'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_get_index_names_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::STRING) {
+ $xfer += $input->readString($this->db_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->tbl_name);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::I16) {
+ $xfer += $input->readI16($this->max_indexes);
+ } 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_get_index_names_args');
+ if ($this->db_name !== null) {
+ $xfer += $output->writeFieldBegin('db_name', TType::STRING, 1);
+ $xfer += $output->writeString($this->db_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->tbl_name !== null) {
+ $xfer += $output->writeFieldBegin('tbl_name', TType::STRING, 2);
+ $xfer += $output->writeString($this->tbl_name);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->max_indexes !== null) {
+ $xfer += $output->writeFieldBegin('max_indexes', TType::I16, 3);
+ $xfer += $output->writeI16($this->max_indexes);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class metastore_ThriftHiveMetastore_get_index_names_result {
+ static $_TSPEC;
+
+ public $success = null;
+ public $o2 = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::LST,
+ 'etype' => TType::STRING,
+ 'elem' => array(
+ 'type' => TType::STRING,
+ ),
+ ),
+ 1 => array(
+ 'var' => 'o2',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_MetaException',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['success'])) {
+ $this->success = $vals['success'];
+ }
+ if (isset($vals['o2'])) {
+ $this->o2 = $vals['o2'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'ThriftHiveMetastore_get_index_names_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();
+ $_size226 = 0;
+ $_etype229 = 0;
+ $xfer += $input->readListBegin($_etype229, $_size226);
+ for ($_i230 = 0; $_i230 < $_size226; ++$_i230)
+ {
+ $elem231 = null;
+ $xfer += $input->readString($elem231);
+ $this->success []= $elem231;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->o2 = new metastore_MetaException();
+ $xfer += $this->o2->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_get_index_names_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::STRING, count($this->success));
+ {
+ foreach ($this->success as $iter232)
+ {
+ $xfer += $output->writeString($iter232);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->o2 !== null) {
+ $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 1);
+ $xfer += $this->o2->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
?>
Modified: hadoop/hive/trunk/metastore/src/gen-php/hive_metastore_types.php
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/metastore/src/gen-php/hive_metastore_types.php?rev=980659&r1=980658&r2=980659&view=diff
==============================================================================
--- hadoop/hive/trunk/metastore/src/gen-php/hive_metastore_types.php (original)
+++ hadoop/hive/trunk/metastore/src/gen-php/hive_metastore_types.php Fri Jul 30 06:40:04 2010
@@ -1695,11 +1695,15 @@ class metastore_Index {
static $_TSPEC;
public $indexName = null;
- public $indexType = null;
- public $tableName = null;
+ public $indexHandlerClass = null;
public $dbName = null;
- public $colNames = null;
- public $partName = null;
+ public $origTableName = null;
+ public $createTime = null;
+ public $lastAccessTime = null;
+ public $indexTableName = null;
+ public $sd = null;
+ public $parameters = null;
+ public $deferredRebuild = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
@@ -1709,49 +1713,82 @@ class metastore_Index {
'type' => TType::STRING,
),
2 => array(
- 'var' => 'indexType',
- 'type' => TType::I32,
+ 'var' => 'indexHandlerClass',
+ 'type' => TType::STRING,
),
3 => array(
- 'var' => 'tableName',
+ 'var' => 'dbName',
'type' => TType::STRING,
),
4 => array(
- 'var' => 'dbName',
+ 'var' => 'origTableName',
'type' => TType::STRING,
),
5 => array(
- 'var' => 'colNames',
- 'type' => TType::LST,
- 'etype' => TType::STRING,
- 'elem' => array(
- 'type' => TType::STRING,
- ),
+ 'var' => 'createTime',
+ 'type' => TType::I32,
),
6 => array(
- 'var' => 'partName',
+ 'var' => 'lastAccessTime',
+ 'type' => TType::I32,
+ ),
+ 7 => array(
+ 'var' => 'indexTableName',
'type' => TType::STRING,
),
+ 8 => array(
+ 'var' => 'sd',
+ 'type' => TType::STRUCT,
+ 'class' => 'metastore_StorageDescriptor',
+ ),
+ 9 => array(
+ 'var' => 'parameters',
+ 'type' => TType::MAP,
+ 'ktype' => TType::STRING,
+ 'vtype' => TType::STRING,
+ 'key' => array(
+ 'type' => TType::STRING,
+ ),
+ 'val' => array(
+ 'type' => TType::STRING,
+ ),
+ ),
+ 10 => array(
+ 'var' => 'deferredRebuild',
+ 'type' => TType::BOOL,
+ ),
);
}
if (is_array($vals)) {
if (isset($vals['indexName'])) {
$this->indexName = $vals['indexName'];
}
- if (isset($vals['indexType'])) {
- $this->indexType = $vals['indexType'];
- }
- if (isset($vals['tableName'])) {
- $this->tableName = $vals['tableName'];
+ if (isset($vals['indexHandlerClass'])) {
+ $this->indexHandlerClass = $vals['indexHandlerClass'];
}
if (isset($vals['dbName'])) {
$this->dbName = $vals['dbName'];
}
- if (isset($vals['colNames'])) {
- $this->colNames = $vals['colNames'];
+ if (isset($vals['origTableName'])) {
+ $this->origTableName = $vals['origTableName'];
+ }
+ if (isset($vals['createTime'])) {
+ $this->createTime = $vals['createTime'];
+ }
+ if (isset($vals['lastAccessTime'])) {
+ $this->lastAccessTime = $vals['lastAccessTime'];
+ }
+ if (isset($vals['indexTableName'])) {
+ $this->indexTableName = $vals['indexTableName'];
+ }
+ if (isset($vals['sd'])) {
+ $this->sd = $vals['sd'];
+ }
+ if (isset($vals['parameters'])) {
+ $this->parameters = $vals['parameters'];
}
- if (isset($vals['partName'])) {
- $this->partName = $vals['partName'];
+ if (isset($vals['deferredRebuild'])) {
+ $this->deferredRebuild = $vals['deferredRebuild'];
}
}
}
@@ -1783,46 +1820,78 @@ class metastore_Index {
}
break;
case 2:
- if ($ftype == TType::I32) {
- $xfer += $input->readI32($this->indexType);
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->indexHandlerClass);
} else {
$xfer += $input->skip($ftype);
}
break;
case 3:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->tableName);
+ $xfer += $input->readString($this->dbName);
} else {
$xfer += $input->skip($ftype);
}
break;
case 4:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->dbName);
+ $xfer += $input->readString($this->origTableName);
} else {
$xfer += $input->skip($ftype);
}
break;
case 5:
- if ($ftype == TType::LST) {
- $this->colNames = array();
+ if ($ftype == TType::I32) {
+ $xfer += $input->readI32($this->createTime);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 6:
+ if ($ftype == TType::I32) {
+ $xfer += $input->readI32($this->lastAccessTime);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 7:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->indexTableName);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 8:
+ if ($ftype == TType::STRUCT) {
+ $this->sd = new metastore_StorageDescriptor();
+ $xfer += $this->sd->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 9:
+ if ($ftype == TType::MAP) {
+ $this->parameters = array();
$_size78 = 0;
- $_etype81 = 0;
- $xfer += $input->readListBegin($_etype81, $_size78);
+ $_ktype79 = 0;
+ $_vtype80 = 0;
+ $xfer += $input->readMapBegin($_ktype79, $_vtype80, $_size78);
for ($_i82 = 0; $_i82 < $_size78; ++$_i82)
{
- $elem83 = null;
- $xfer += $input->readString($elem83);
- $this->colNames []= $elem83;
+ $key83 = '';
+ $val84 = '';
+ $xfer += $input->readString($key83);
+ $xfer += $input->readString($val84);
+ $this->parameters[$key83] = $val84;
}
- $xfer += $input->readListEnd();
+ $xfer += $input->readMapEnd();
} else {
$xfer += $input->skip($ftype);
}
break;
- case 6:
- if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->partName);
+ case 10:
+ if ($ftype == TType::BOOL) {
+ $xfer += $input->readBool($this->deferredRebuild);
} else {
$xfer += $input->skip($ftype);
}
@@ -1845,41 +1914,65 @@ class metastore_Index {
$xfer += $output->writeString($this->indexName);
$xfer += $output->writeFieldEnd();
}
- if ($this->indexType !== null) {
- $xfer += $output->writeFieldBegin('indexType', TType::I32, 2);
- $xfer += $output->writeI32($this->indexType);
- $xfer += $output->writeFieldEnd();
- }
- if ($this->tableName !== null) {
- $xfer += $output->writeFieldBegin('tableName', TType::STRING, 3);
- $xfer += $output->writeString($this->tableName);
+ if ($this->indexHandlerClass !== null) {
+ $xfer += $output->writeFieldBegin('indexHandlerClass', TType::STRING, 2);
+ $xfer += $output->writeString($this->indexHandlerClass);
$xfer += $output->writeFieldEnd();
}
if ($this->dbName !== null) {
- $xfer += $output->writeFieldBegin('dbName', TType::STRING, 4);
+ $xfer += $output->writeFieldBegin('dbName', TType::STRING, 3);
$xfer += $output->writeString($this->dbName);
$xfer += $output->writeFieldEnd();
}
- if ($this->colNames !== null) {
- if (!is_array($this->colNames)) {
+ if ($this->origTableName !== null) {
+ $xfer += $output->writeFieldBegin('origTableName', TType::STRING, 4);
+ $xfer += $output->writeString($this->origTableName);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->createTime !== null) {
+ $xfer += $output->writeFieldBegin('createTime', TType::I32, 5);
+ $xfer += $output->writeI32($this->createTime);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->lastAccessTime !== null) {
+ $xfer += $output->writeFieldBegin('lastAccessTime', TType::I32, 6);
+ $xfer += $output->writeI32($this->lastAccessTime);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->indexTableName !== null) {
+ $xfer += $output->writeFieldBegin('indexTableName', TType::STRING, 7);
+ $xfer += $output->writeString($this->indexTableName);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->sd !== null) {
+ if (!is_object($this->sd)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
- $xfer += $output->writeFieldBegin('colNames', TType::LST, 5);
+ $xfer += $output->writeFieldBegin('sd', TType::STRUCT, 8);
+ $xfer += $this->sd->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->parameters !== null) {
+ if (!is_array($this->parameters)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('parameters', TType::MAP, 9);
{
- $output->writeListBegin(TType::STRING, count($this->colNames));
+ $output->writeMapBegin(TType::STRING, TType::STRING, count($this->parameters));
{
- foreach ($this->colNames as $iter84)
+ foreach ($this->parameters as $kiter85 => $viter86)
{
- $xfer += $output->writeString($iter84);
+ $xfer += $output->writeString($kiter85);
+ $xfer += $output->writeString($viter86);
}
}
- $output->writeListEnd();
+ $output->writeMapEnd();
}
$xfer += $output->writeFieldEnd();
}
- if ($this->partName !== null) {
- $xfer += $output->writeFieldBegin('partName', TType::STRING, 6);
- $xfer += $output->writeString($this->partName);
+ if ($this->deferredRebuild !== null) {
+ $xfer += $output->writeFieldBegin('deferredRebuild', TType::BOOL, 10);
+ $xfer += $output->writeBool($this->deferredRebuild);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
@@ -1953,15 +2046,15 @@ class metastore_Schema {
case 1:
if ($ftype == TType::LST) {
$this->fieldSchemas = array();
- $_size85 = 0;
- $_etype88 = 0;
- $xfer += $input->readListBegin($_etype88, $_size85);
- for ($_i89 = 0; $_i89 < $_size85; ++$_i89)
+ $_size87 = 0;
+ $_etype90 = 0;
+ $xfer += $input->readListBegin($_etype90, $_size87);
+ for ($_i91 = 0; $_i91 < $_size87; ++$_i91)
{
- $elem90 = null;
- $elem90 = new metastore_FieldSchema();
- $xfer += $elem90->read($input);
- $this->fieldSchemas []= $elem90;
+ $elem92 = null;
+ $elem92 = new metastore_FieldSchema();
+ $xfer += $elem92->read($input);
+ $this->fieldSchemas []= $elem92;
}
$xfer += $input->readListEnd();
} else {
@@ -1971,17 +2064,17 @@ class metastore_Schema {
case 2:
if ($ftype == TType::MAP) {
$this->properties = array();
- $_size91 = 0;
- $_ktype92 = 0;
- $_vtype93 = 0;
- $xfer += $input->readMapBegin($_ktype92, $_vtype93, $_size91);
- for ($_i95 = 0; $_i95 < $_size91; ++$_i95)
+ $_size93 = 0;
+ $_ktype94 = 0;
+ $_vtype95 = 0;
+ $xfer += $input->readMapBegin($_ktype94, $_vtype95, $_size93);
+ for ($_i97 = 0; $_i97 < $_size93; ++$_i97)
{
- $key96 = '';
- $val97 = '';
- $xfer += $input->readString($key96);
- $xfer += $input->readString($val97);
- $this->properties[$key96] = $val97;
+ $key98 = '';
+ $val99 = '';
+ $xfer += $input->readString($key98);
+ $xfer += $input->readString($val99);
+ $this->properties[$key98] = $val99;
}
$xfer += $input->readMapEnd();
} else {
@@ -2009,9 +2102,9 @@ class metastore_Schema {
{
$output->writeListBegin(TType::STRUCT, count($this->fieldSchemas));
{
- foreach ($this->fieldSchemas as $iter98)
+ foreach ($this->fieldSchemas as $iter100)
{
- $xfer += $iter98->write($output);
+ $xfer += $iter100->write($output);
}
}
$output->writeListEnd();
@@ -2026,10 +2119,10 @@ class metastore_Schema {
{
$output->writeMapBegin(TType::STRING, TType::STRING, count($this->properties));
{
- foreach ($this->properties as $kiter99 => $viter100)
+ foreach ($this->properties as $kiter101 => $viter102)
{
- $xfer += $output->writeString($kiter99);
- $xfer += $output->writeString($viter100);
+ $xfer += $output->writeString($kiter101);
+ $xfer += $output->writeString($viter102);
}
}
$output->writeMapEnd();
Modified: hadoop/hive/trunk/metastore/src/gen-py/hive_metastore/ThriftHiveMetastore-remote
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/metastore/src/gen-py/hive_metastore/ThriftHiveMetastore-remote?rev=980659&r1=980658&r2=980659&view=diff
==============================================================================
--- hadoop/hive/trunk/metastore/src/gen-py/hive_metastore/ThriftHiveMetastore-remote (original)
+++ hadoop/hive/trunk/metastore/src/gen-py/hive_metastore/ThriftHiveMetastore-remote Fri Jul 30 06:40:04 2010
@@ -51,6 +51,11 @@ if len(sys.argv) <= 1 or sys.argv[1] ==
print ' string get_config_value(string name, string defaultValue)'
print ' partition_name_to_vals(string part_name)'
print ' partition_name_to_spec(string part_name)'
+ print ' Index add_index(Index new_index, Table index_table)'
+ print ' bool drop_index_by_name(string db_name, string tbl_name, string index_name, bool deleteData)'
+ print ' Index get_index_by_name(string db_name, string tbl_name, string index_name)'
+ print ' get_indexes(string db_name, string tbl_name, i16 max_indexes)'
+ print ' get_index_names(string db_name, string tbl_name, i16 max_indexes)'
print ''
sys.exit(0)
@@ -279,4 +284,34 @@ elif cmd == 'partition_name_to_spec':
sys.exit(1)
pp.pprint(client.partition_name_to_spec(args[0],))
+elif cmd == 'add_index':
+ if len(args) != 2:
+ print 'add_index requires 2 args'
+ sys.exit(1)
+ pp.pprint(client.add_index(eval(args[0]),eval(args[1]),))
+
+elif cmd == 'drop_index_by_name':
+ if len(args) != 4:
+ print 'drop_index_by_name requires 4 args'
+ sys.exit(1)
+ pp.pprint(client.drop_index_by_name(args[0],args[1],args[2],eval(args[3]),))
+
+elif cmd == 'get_index_by_name':
+ if len(args) != 3:
+ print 'get_index_by_name requires 3 args'
+ sys.exit(1)
+ pp.pprint(client.get_index_by_name(args[0],args[1],args[2],))
+
+elif cmd == 'get_indexes':
+ if len(args) != 3:
+ print 'get_indexes requires 3 args'
+ sys.exit(1)
+ pp.pprint(client.get_indexes(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'get_index_names':
+ if len(args) != 3:
+ print 'get_index_names requires 3 args'
+ sys.exit(1)
+ pp.pprint(client.get_index_names(args[0],args[1],eval(args[2]),))
+
transport.close()