FAQ
http://git-wip-us.apache.org/repos/asf/hive/blob/3a1c4b57/service-rpc/src/gen/thrift/gen-php/Types.php
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-php/Types.php b/service-rpc/src/gen/thrift/gen-php/Types.php
new file mode 100644
index 0000000..76805df
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-php/Types.php
@@ -0,0 +1,9038 @@
+<?php
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+
+final class TProtocolVersion {
+ const HIVE_CLI_SERVICE_PROTOCOL_V1 = 0;
+ const HIVE_CLI_SERVICE_PROTOCOL_V2 = 1;
+ const HIVE_CLI_SERVICE_PROTOCOL_V3 = 2;
+ const HIVE_CLI_SERVICE_PROTOCOL_V4 = 3;
+ const HIVE_CLI_SERVICE_PROTOCOL_V5 = 4;
+ const HIVE_CLI_SERVICE_PROTOCOL_V6 = 5;
+ const HIVE_CLI_SERVICE_PROTOCOL_V7 = 6;
+ const HIVE_CLI_SERVICE_PROTOCOL_V8 = 7;
+ static public $__names = array(
+ 0 => 'HIVE_CLI_SERVICE_PROTOCOL_V1',
+ 1 => 'HIVE_CLI_SERVICE_PROTOCOL_V2',
+ 2 => 'HIVE_CLI_SERVICE_PROTOCOL_V3',
+ 3 => 'HIVE_CLI_SERVICE_PROTOCOL_V4',
+ 4 => 'HIVE_CLI_SERVICE_PROTOCOL_V5',
+ 5 => 'HIVE_CLI_SERVICE_PROTOCOL_V6',
+ 6 => 'HIVE_CLI_SERVICE_PROTOCOL_V7',
+ 7 => 'HIVE_CLI_SERVICE_PROTOCOL_V8',
+ );
+}
+
+final class TTypeId {
+ const BOOLEAN_TYPE = 0;
+ const TINYINT_TYPE = 1;
+ const SMALLINT_TYPE = 2;
+ const INT_TYPE = 3;
+ const BIGINT_TYPE = 4;
+ const FLOAT_TYPE = 5;
+ const DOUBLE_TYPE = 6;
+ const STRING_TYPE = 7;
+ const TIMESTAMP_TYPE = 8;
+ const BINARY_TYPE = 9;
+ const ARRAY_TYPE = 10;
+ const MAP_TYPE = 11;
+ const STRUCT_TYPE = 12;
+ const UNION_TYPE = 13;
+ const USER_DEFINED_TYPE = 14;
+ const DECIMAL_TYPE = 15;
+ const NULL_TYPE = 16;
+ const DATE_TYPE = 17;
+ const VARCHAR_TYPE = 18;
+ const CHAR_TYPE = 19;
+ const INTERVAL_YEAR_MONTH_TYPE = 20;
+ const INTERVAL_DAY_TIME_TYPE = 21;
+ static public $__names = array(
+ 0 => 'BOOLEAN_TYPE',
+ 1 => 'TINYINT_TYPE',
+ 2 => 'SMALLINT_TYPE',
+ 3 => 'INT_TYPE',
+ 4 => 'BIGINT_TYPE',
+ 5 => 'FLOAT_TYPE',
+ 6 => 'DOUBLE_TYPE',
+ 7 => 'STRING_TYPE',
+ 8 => 'TIMESTAMP_TYPE',
+ 9 => 'BINARY_TYPE',
+ 10 => 'ARRAY_TYPE',
+ 11 => 'MAP_TYPE',
+ 12 => 'STRUCT_TYPE',
+ 13 => 'UNION_TYPE',
+ 14 => 'USER_DEFINED_TYPE',
+ 15 => 'DECIMAL_TYPE',
+ 16 => 'NULL_TYPE',
+ 17 => 'DATE_TYPE',
+ 18 => 'VARCHAR_TYPE',
+ 19 => 'CHAR_TYPE',
+ 20 => 'INTERVAL_YEAR_MONTH_TYPE',
+ 21 => 'INTERVAL_DAY_TIME_TYPE',
+ );
+}
+
+final class TStatusCode {
+ const SUCCESS_STATUS = 0;
+ const SUCCESS_WITH_INFO_STATUS = 1;
+ const STILL_EXECUTING_STATUS = 2;
+ const ERROR_STATUS = 3;
+ const INVALID_HANDLE_STATUS = 4;
+ static public $__names = array(
+ 0 => 'SUCCESS_STATUS',
+ 1 => 'SUCCESS_WITH_INFO_STATUS',
+ 2 => 'STILL_EXECUTING_STATUS',
+ 3 => 'ERROR_STATUS',
+ 4 => 'INVALID_HANDLE_STATUS',
+ );
+}
+
+final class TOperationState {
+ const INITIALIZED_STATE = 0;
+ const RUNNING_STATE = 1;
+ const FINISHED_STATE = 2;
+ const CANCELED_STATE = 3;
+ const CLOSED_STATE = 4;
+ const ERROR_STATE = 5;
+ const UKNOWN_STATE = 6;
+ const PENDING_STATE = 7;
+ static public $__names = array(
+ 0 => 'INITIALIZED_STATE',
+ 1 => 'RUNNING_STATE',
+ 2 => 'FINISHED_STATE',
+ 3 => 'CANCELED_STATE',
+ 4 => 'CLOSED_STATE',
+ 5 => 'ERROR_STATE',
+ 6 => 'UKNOWN_STATE',
+ 7 => 'PENDING_STATE',
+ );
+}
+
+final class TOperationType {
+ const EXECUTE_STATEMENT = 0;
+ const GET_TYPE_INFO = 1;
+ const GET_CATALOGS = 2;
+ const GET_SCHEMAS = 3;
+ const GET_TABLES = 4;
+ const GET_TABLE_TYPES = 5;
+ const GET_COLUMNS = 6;
+ const GET_FUNCTIONS = 7;
+ const UNKNOWN = 8;
+ static public $__names = array(
+ 0 => 'EXECUTE_STATEMENT',
+ 1 => 'GET_TYPE_INFO',
+ 2 => 'GET_CATALOGS',
+ 3 => 'GET_SCHEMAS',
+ 4 => 'GET_TABLES',
+ 5 => 'GET_TABLE_TYPES',
+ 6 => 'GET_COLUMNS',
+ 7 => 'GET_FUNCTIONS',
+ 8 => 'UNKNOWN',
+ );
+}
+
+final class TGetInfoType {
+ const CLI_MAX_DRIVER_CONNECTIONS = 0;
+ const CLI_MAX_CONCURRENT_ACTIVITIES = 1;
+ const CLI_DATA_SOURCE_NAME = 2;
+ const CLI_FETCH_DIRECTION = 8;
+ const CLI_SERVER_NAME = 13;
+ const CLI_SEARCH_PATTERN_ESCAPE = 14;
+ const CLI_DBMS_NAME = 17;
+ const CLI_DBMS_VER = 18;
+ const CLI_ACCESSIBLE_TABLES = 19;
+ const CLI_ACCESSIBLE_PROCEDURES = 20;
+ const CLI_CURSOR_COMMIT_BEHAVIOR = 23;
+ const CLI_DATA_SOURCE_READ_ONLY = 25;
+ const CLI_DEFAULT_TXN_ISOLATION = 26;
+ const CLI_IDENTIFIER_CASE = 28;
+ const CLI_IDENTIFIER_QUOTE_CHAR = 29;
+ const CLI_MAX_COLUMN_NAME_LEN = 30;
+ const CLI_MAX_CURSOR_NAME_LEN = 31;
+ const CLI_MAX_SCHEMA_NAME_LEN = 32;
+ const CLI_MAX_CATALOG_NAME_LEN = 34;
+ const CLI_MAX_TABLE_NAME_LEN = 35;
+ const CLI_SCROLL_CONCURRENCY = 43;
+ const CLI_TXN_CAPABLE = 46;
+ const CLI_USER_NAME = 47;
+ const CLI_TXN_ISOLATION_OPTION = 72;
+ const CLI_INTEGRITY = 73;
+ const CLI_GETDATA_EXTENSIONS = 81;
+ const CLI_NULL_COLLATION = 85;
+ const CLI_ALTER_TABLE = 86;
+ const CLI_ORDER_BY_COLUMNS_IN_SELECT = 90;
+ const CLI_SPECIAL_CHARACTERS = 94;
+ const CLI_MAX_COLUMNS_IN_GROUP_BY = 97;
+ const CLI_MAX_COLUMNS_IN_INDEX = 98;
+ const CLI_MAX_COLUMNS_IN_ORDER_BY = 99;
+ const CLI_MAX_COLUMNS_IN_SELECT = 100;
+ const CLI_MAX_COLUMNS_IN_TABLE = 101;
+ const CLI_MAX_INDEX_SIZE = 102;
+ const CLI_MAX_ROW_SIZE = 104;
+ const CLI_MAX_STATEMENT_LEN = 105;
+ const CLI_MAX_TABLES_IN_SELECT = 106;
+ const CLI_MAX_USER_NAME_LEN = 107;
+ const CLI_OJ_CAPABILITIES = 115;
+ const CLI_XOPEN_CLI_YEAR = 10000;
+ const CLI_CURSOR_SENSITIVITY = 10001;
+ const CLI_DESCRIBE_PARAMETER = 10002;
+ const CLI_CATALOG_NAME = 10003;
+ const CLI_COLLATION_SEQ = 10004;
+ const CLI_MAX_IDENTIFIER_LEN = 10005;
+ static public $__names = array(
+ 0 => 'CLI_MAX_DRIVER_CONNECTIONS',
+ 1 => 'CLI_MAX_CONCURRENT_ACTIVITIES',
+ 2 => 'CLI_DATA_SOURCE_NAME',
+ 8 => 'CLI_FETCH_DIRECTION',
+ 13 => 'CLI_SERVER_NAME',
+ 14 => 'CLI_SEARCH_PATTERN_ESCAPE',
+ 17 => 'CLI_DBMS_NAME',
+ 18 => 'CLI_DBMS_VER',
+ 19 => 'CLI_ACCESSIBLE_TABLES',
+ 20 => 'CLI_ACCESSIBLE_PROCEDURES',
+ 23 => 'CLI_CURSOR_COMMIT_BEHAVIOR',
+ 25 => 'CLI_DATA_SOURCE_READ_ONLY',
+ 26 => 'CLI_DEFAULT_TXN_ISOLATION',
+ 28 => 'CLI_IDENTIFIER_CASE',
+ 29 => 'CLI_IDENTIFIER_QUOTE_CHAR',
+ 30 => 'CLI_MAX_COLUMN_NAME_LEN',
+ 31 => 'CLI_MAX_CURSOR_NAME_LEN',
+ 32 => 'CLI_MAX_SCHEMA_NAME_LEN',
+ 34 => 'CLI_MAX_CATALOG_NAME_LEN',
+ 35 => 'CLI_MAX_TABLE_NAME_LEN',
+ 43 => 'CLI_SCROLL_CONCURRENCY',
+ 46 => 'CLI_TXN_CAPABLE',
+ 47 => 'CLI_USER_NAME',
+ 72 => 'CLI_TXN_ISOLATION_OPTION',
+ 73 => 'CLI_INTEGRITY',
+ 81 => 'CLI_GETDATA_EXTENSIONS',
+ 85 => 'CLI_NULL_COLLATION',
+ 86 => 'CLI_ALTER_TABLE',
+ 90 => 'CLI_ORDER_BY_COLUMNS_IN_SELECT',
+ 94 => 'CLI_SPECIAL_CHARACTERS',
+ 97 => 'CLI_MAX_COLUMNS_IN_GROUP_BY',
+ 98 => 'CLI_MAX_COLUMNS_IN_INDEX',
+ 99 => 'CLI_MAX_COLUMNS_IN_ORDER_BY',
+ 100 => 'CLI_MAX_COLUMNS_IN_SELECT',
+ 101 => 'CLI_MAX_COLUMNS_IN_TABLE',
+ 102 => 'CLI_MAX_INDEX_SIZE',
+ 104 => 'CLI_MAX_ROW_SIZE',
+ 105 => 'CLI_MAX_STATEMENT_LEN',
+ 106 => 'CLI_MAX_TABLES_IN_SELECT',
+ 107 => 'CLI_MAX_USER_NAME_LEN',
+ 115 => 'CLI_OJ_CAPABILITIES',
+ 10000 => 'CLI_XOPEN_CLI_YEAR',
+ 10001 => 'CLI_CURSOR_SENSITIVITY',
+ 10002 => 'CLI_DESCRIBE_PARAMETER',
+ 10003 => 'CLI_CATALOG_NAME',
+ 10004 => 'CLI_COLLATION_SEQ',
+ 10005 => 'CLI_MAX_IDENTIFIER_LEN',
+ );
+}
+
+final class TFetchOrientation {
+ const FETCH_NEXT = 0;
+ const FETCH_PRIOR = 1;
+ const FETCH_RELATIVE = 2;
+ const FETCH_ABSOLUTE = 3;
+ const FETCH_FIRST = 4;
+ const FETCH_LAST = 5;
+ static public $__names = array(
+ 0 => 'FETCH_NEXT',
+ 1 => 'FETCH_PRIOR',
+ 2 => 'FETCH_RELATIVE',
+ 3 => 'FETCH_ABSOLUTE',
+ 4 => 'FETCH_FIRST',
+ 5 => 'FETCH_LAST',
+ );
+}
+
+class TTypeQualifierValue {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $i32Value = null;
+ /**
+ * @var string
+ */
+ public $stringValue = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'i32Value',
+ 'type' => TType::I32,
+ ),
+ 2 => array(
+ 'var' => 'stringValue',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['i32Value'])) {
+ $this->i32Value = $vals['i32Value'];
+ }
+ if (isset($vals['stringValue'])) {
+ $this->stringValue = $vals['stringValue'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TTypeQualifierValue';
+ }
+
+ 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::I32) {
+ $xfer += $input->readI32($this->i32Value);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->stringValue);
+ } 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('TTypeQualifierValue');
+ if ($this->i32Value !== null) {
+ $xfer += $output->writeFieldBegin('i32Value', TType::I32, 1);
+ $xfer += $output->writeI32($this->i32Value);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->stringValue !== null) {
+ $xfer += $output->writeFieldBegin('stringValue', TType::STRING, 2);
+ $xfer += $output->writeString($this->stringValue);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TTypeQualifiers {
+ static $_TSPEC;
+
+ /**
+ * @var array
+ */
+ public $qualifiers = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'qualifiers',
+ 'type' => TType::MAP,
+ 'ktype' => TType::STRING,
+ 'vtype' => TType::STRUCT,
+ 'key' => array(
+ 'type' => TType::STRING,
+ ),
+ 'val' => array(
+ 'type' => TType::STRUCT,
+ 'class' => '\TTypeQualifierValue',
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['qualifiers'])) {
+ $this->qualifiers = $vals['qualifiers'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TTypeQualifiers';
+ }
+
+ 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->qualifiers = array();
+ $_size0 = 0;
+ $_ktype1 = 0;
+ $_vtype2 = 0;
+ $xfer += $input->readMapBegin($_ktype1, $_vtype2, $_size0);
+ for ($_i4 = 0; $_i4 < $_size0; ++$_i4)
+ {
+ $key5 = '';
+ $val6 = new \TTypeQualifierValue();
+ $xfer += $input->readString($key5);
+ $val6 = new \TTypeQualifierValue();
+ $xfer += $val6->read($input);
+ $this->qualifiers[$key5] = $val6;
+ }
+ $xfer += $input->readMapEnd();
+ } 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('TTypeQualifiers');
+ if ($this->qualifiers !== null) {
+ if (!is_array($this->qualifiers)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('qualifiers', TType::MAP, 1);
+ {
+ $output->writeMapBegin(TType::STRING, TType::STRUCT, count($this->qualifiers));
+ {
+ foreach ($this->qualifiers as $kiter7 => $viter8)
+ {
+ $xfer += $output->writeString($kiter7);
+ $xfer += $viter8->write($output);
+ }
+ }
+ $output->writeMapEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TPrimitiveTypeEntry {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $type = null;
+ /**
+ * @var \TTypeQualifiers
+ */
+ public $typeQualifiers = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'type',
+ 'type' => TType::I32,
+ ),
+ 2 => array(
+ 'var' => 'typeQualifiers',
+ 'type' => TType::STRUCT,
+ 'class' => '\TTypeQualifiers',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['type'])) {
+ $this->type = $vals['type'];
+ }
+ if (isset($vals['typeQualifiers'])) {
+ $this->typeQualifiers = $vals['typeQualifiers'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TPrimitiveTypeEntry';
+ }
+
+ 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::I32) {
+ $xfer += $input->readI32($this->type);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->typeQualifiers = new \TTypeQualifiers();
+ $xfer += $this->typeQualifiers->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('TPrimitiveTypeEntry');
+ if ($this->type !== null) {
+ $xfer += $output->writeFieldBegin('type', TType::I32, 1);
+ $xfer += $output->writeI32($this->type);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->typeQualifiers !== null) {
+ if (!is_object($this->typeQualifiers)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('typeQualifiers', TType::STRUCT, 2);
+ $xfer += $this->typeQualifiers->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TArrayTypeEntry {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $objectTypePtr = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'objectTypePtr',
+ 'type' => TType::I32,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['objectTypePtr'])) {
+ $this->objectTypePtr = $vals['objectTypePtr'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TArrayTypeEntry';
+ }
+
+ 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::I32) {
+ $xfer += $input->readI32($this->objectTypePtr);
+ } 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('TArrayTypeEntry');
+ if ($this->objectTypePtr !== null) {
+ $xfer += $output->writeFieldBegin('objectTypePtr', TType::I32, 1);
+ $xfer += $output->writeI32($this->objectTypePtr);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TMapTypeEntry {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $keyTypePtr = null;
+ /**
+ * @var int
+ */
+ public $valueTypePtr = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'keyTypePtr',
+ 'type' => TType::I32,
+ ),
+ 2 => array(
+ 'var' => 'valueTypePtr',
+ 'type' => TType::I32,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['keyTypePtr'])) {
+ $this->keyTypePtr = $vals['keyTypePtr'];
+ }
+ if (isset($vals['valueTypePtr'])) {
+ $this->valueTypePtr = $vals['valueTypePtr'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TMapTypeEntry';
+ }
+
+ 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::I32) {
+ $xfer += $input->readI32($this->keyTypePtr);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::I32) {
+ $xfer += $input->readI32($this->valueTypePtr);
+ } 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('TMapTypeEntry');
+ if ($this->keyTypePtr !== null) {
+ $xfer += $output->writeFieldBegin('keyTypePtr', TType::I32, 1);
+ $xfer += $output->writeI32($this->keyTypePtr);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->valueTypePtr !== null) {
+ $xfer += $output->writeFieldBegin('valueTypePtr', TType::I32, 2);
+ $xfer += $output->writeI32($this->valueTypePtr);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TStructTypeEntry {
+ static $_TSPEC;
+
+ /**
+ * @var array
+ */
+ public $nameToTypePtr = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'nameToTypePtr',
+ 'type' => TType::MAP,
+ 'ktype' => TType::STRING,
+ 'vtype' => TType::I32,
+ 'key' => array(
+ 'type' => TType::STRING,
+ ),
+ 'val' => array(
+ 'type' => TType::I32,
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['nameToTypePtr'])) {
+ $this->nameToTypePtr = $vals['nameToTypePtr'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TStructTypeEntry';
+ }
+
+ 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->nameToTypePtr = array();
+ $_size9 = 0;
+ $_ktype10 = 0;
+ $_vtype11 = 0;
+ $xfer += $input->readMapBegin($_ktype10, $_vtype11, $_size9);
+ for ($_i13 = 0; $_i13 < $_size9; ++$_i13)
+ {
+ $key14 = '';
+ $val15 = 0;
+ $xfer += $input->readString($key14);
+ $xfer += $input->readI32($val15);
+ $this->nameToTypePtr[$key14] = $val15;
+ }
+ $xfer += $input->readMapEnd();
+ } 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('TStructTypeEntry');
+ if ($this->nameToTypePtr !== null) {
+ if (!is_array($this->nameToTypePtr)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('nameToTypePtr', TType::MAP, 1);
+ {
+ $output->writeMapBegin(TType::STRING, TType::I32, count($this->nameToTypePtr));
+ {
+ foreach ($this->nameToTypePtr as $kiter16 => $viter17)
+ {
+ $xfer += $output->writeString($kiter16);
+ $xfer += $output->writeI32($viter17);
+ }
+ }
+ $output->writeMapEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TUnionTypeEntry {
+ static $_TSPEC;
+
+ /**
+ * @var array
+ */
+ public $nameToTypePtr = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'nameToTypePtr',
+ 'type' => TType::MAP,
+ 'ktype' => TType::STRING,
+ 'vtype' => TType::I32,
+ 'key' => array(
+ 'type' => TType::STRING,
+ ),
+ 'val' => array(
+ 'type' => TType::I32,
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['nameToTypePtr'])) {
+ $this->nameToTypePtr = $vals['nameToTypePtr'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TUnionTypeEntry';
+ }
+
+ 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->nameToTypePtr = array();
+ $_size18 = 0;
+ $_ktype19 = 0;
+ $_vtype20 = 0;
+ $xfer += $input->readMapBegin($_ktype19, $_vtype20, $_size18);
+ for ($_i22 = 0; $_i22 < $_size18; ++$_i22)
+ {
+ $key23 = '';
+ $val24 = 0;
+ $xfer += $input->readString($key23);
+ $xfer += $input->readI32($val24);
+ $this->nameToTypePtr[$key23] = $val24;
+ }
+ $xfer += $input->readMapEnd();
+ } 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('TUnionTypeEntry');
+ if ($this->nameToTypePtr !== null) {
+ if (!is_array($this->nameToTypePtr)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('nameToTypePtr', TType::MAP, 1);
+ {
+ $output->writeMapBegin(TType::STRING, TType::I32, count($this->nameToTypePtr));
+ {
+ foreach ($this->nameToTypePtr as $kiter25 => $viter26)
+ {
+ $xfer += $output->writeString($kiter25);
+ $xfer += $output->writeI32($viter26);
+ }
+ }
+ $output->writeMapEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TUserDefinedTypeEntry {
+ static $_TSPEC;
+
+ /**
+ * @var string
+ */
+ public $typeClassName = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'typeClassName',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['typeClassName'])) {
+ $this->typeClassName = $vals['typeClassName'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TUserDefinedTypeEntry';
+ }
+
+ 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->typeClassName);
+ } 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('TUserDefinedTypeEntry');
+ if ($this->typeClassName !== null) {
+ $xfer += $output->writeFieldBegin('typeClassName', TType::STRING, 1);
+ $xfer += $output->writeString($this->typeClassName);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TTypeEntry {
+ static $_TSPEC;
+
+ /**
+ * @var \TPrimitiveTypeEntry
+ */
+ public $primitiveEntry = null;
+ /**
+ * @var \TArrayTypeEntry
+ */
+ public $arrayEntry = null;
+ /**
+ * @var \TMapTypeEntry
+ */
+ public $mapEntry = null;
+ /**
+ * @var \TStructTypeEntry
+ */
+ public $structEntry = null;
+ /**
+ * @var \TUnionTypeEntry
+ */
+ public $unionEntry = null;
+ /**
+ * @var \TUserDefinedTypeEntry
+ */
+ public $userDefinedTypeEntry = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'primitiveEntry',
+ 'type' => TType::STRUCT,
+ 'class' => '\TPrimitiveTypeEntry',
+ ),
+ 2 => array(
+ 'var' => 'arrayEntry',
+ 'type' => TType::STRUCT,
+ 'class' => '\TArrayTypeEntry',
+ ),
+ 3 => array(
+ 'var' => 'mapEntry',
+ 'type' => TType::STRUCT,
+ 'class' => '\TMapTypeEntry',
+ ),
+ 4 => array(
+ 'var' => 'structEntry',
+ 'type' => TType::STRUCT,
+ 'class' => '\TStructTypeEntry',
+ ),
+ 5 => array(
+ 'var' => 'unionEntry',
+ 'type' => TType::STRUCT,
+ 'class' => '\TUnionTypeEntry',
+ ),
+ 6 => array(
+ 'var' => 'userDefinedTypeEntry',
+ 'type' => TType::STRUCT,
+ 'class' => '\TUserDefinedTypeEntry',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['primitiveEntry'])) {
+ $this->primitiveEntry = $vals['primitiveEntry'];
+ }
+ if (isset($vals['arrayEntry'])) {
+ $this->arrayEntry = $vals['arrayEntry'];
+ }
+ if (isset($vals['mapEntry'])) {
+ $this->mapEntry = $vals['mapEntry'];
+ }
+ if (isset($vals['structEntry'])) {
+ $this->structEntry = $vals['structEntry'];
+ }
+ if (isset($vals['unionEntry'])) {
+ $this->unionEntry = $vals['unionEntry'];
+ }
+ if (isset($vals['userDefinedTypeEntry'])) {
+ $this->userDefinedTypeEntry = $vals['userDefinedTypeEntry'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TTypeEntry';
+ }
+
+ 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->primitiveEntry = new \TPrimitiveTypeEntry();
+ $xfer += $this->primitiveEntry->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->arrayEntry = new \TArrayTypeEntry();
+ $xfer += $this->arrayEntry->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRUCT) {
+ $this->mapEntry = new \TMapTypeEntry();
+ $xfer += $this->mapEntry->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::STRUCT) {
+ $this->structEntry = new \TStructTypeEntry();
+ $xfer += $this->structEntry->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 5:
+ if ($ftype == TType::STRUCT) {
+ $this->unionEntry = new \TUnionTypeEntry();
+ $xfer += $this->unionEntry->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 6:
+ if ($ftype == TType::STRUCT) {
+ $this->userDefinedTypeEntry = new \TUserDefinedTypeEntry();
+ $xfer += $this->userDefinedTypeEntry->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('TTypeEntry');
+ if ($this->primitiveEntry !== null) {
+ if (!is_object($this->primitiveEntry)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('primitiveEntry', TType::STRUCT, 1);
+ $xfer += $this->primitiveEntry->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->arrayEntry !== null) {
+ if (!is_object($this->arrayEntry)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('arrayEntry', TType::STRUCT, 2);
+ $xfer += $this->arrayEntry->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->mapEntry !== null) {
+ if (!is_object($this->mapEntry)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('mapEntry', TType::STRUCT, 3);
+ $xfer += $this->mapEntry->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->structEntry !== null) {
+ if (!is_object($this->structEntry)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('structEntry', TType::STRUCT, 4);
+ $xfer += $this->structEntry->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->unionEntry !== null) {
+ if (!is_object($this->unionEntry)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('unionEntry', TType::STRUCT, 5);
+ $xfer += $this->unionEntry->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->userDefinedTypeEntry !== null) {
+ if (!is_object($this->userDefinedTypeEntry)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('userDefinedTypeEntry', TType::STRUCT, 6);
+ $xfer += $this->userDefinedTypeEntry->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TTypeDesc {
+ static $_TSPEC;
+
+ /**
+ * @var \TTypeEntry[]
+ */
+ public $types = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'types',
+ 'type' => TType::LST,
+ 'etype' => TType::STRUCT,
+ 'elem' => array(
+ 'type' => TType::STRUCT,
+ 'class' => '\TTypeEntry',
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['types'])) {
+ $this->types = $vals['types'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TTypeDesc';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->types = array();
+ $_size27 = 0;
+ $_etype30 = 0;
+ $xfer += $input->readListBegin($_etype30, $_size27);
+ for ($_i31 = 0; $_i31 < $_size27; ++$_i31)
+ {
+ $elem32 = null;
+ $elem32 = new \TTypeEntry();
+ $xfer += $elem32->read($input);
+ $this->types []= $elem32;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TTypeDesc');
+ if ($this->types !== null) {
+ if (!is_array($this->types)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('types', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::STRUCT, count($this->types));
+ {
+ foreach ($this->types as $iter33)
+ {
+ $xfer += $iter33->write($output);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TColumnDesc {
+ static $_TSPEC;
+
+ /**
+ * @var string
+ */
+ public $columnName = null;
+ /**
+ * @var \TTypeDesc
+ */
+ public $typeDesc = null;
+ /**
+ * @var int
+ */
+ public $position = null;
+ /**
+ * @var string
+ */
+ public $comment = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'columnName',
+ 'type' => TType::STRING,
+ ),
+ 2 => array(
+ 'var' => 'typeDesc',
+ 'type' => TType::STRUCT,
+ 'class' => '\TTypeDesc',
+ ),
+ 3 => array(
+ 'var' => 'position',
+ 'type' => TType::I32,
+ ),
+ 4 => array(
+ 'var' => 'comment',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['columnName'])) {
+ $this->columnName = $vals['columnName'];
+ }
+ if (isset($vals['typeDesc'])) {
+ $this->typeDesc = $vals['typeDesc'];
+ }
+ if (isset($vals['position'])) {
+ $this->position = $vals['position'];
+ }
+ if (isset($vals['comment'])) {
+ $this->comment = $vals['comment'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TColumnDesc';
+ }
+
+ 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->columnName);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->typeDesc = new \TTypeDesc();
+ $xfer += $this->typeDesc->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::I32) {
+ $xfer += $input->readI32($this->position);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->comment);
+ } 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('TColumnDesc');
+ if ($this->columnName !== null) {
+ $xfer += $output->writeFieldBegin('columnName', TType::STRING, 1);
+ $xfer += $output->writeString($this->columnName);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->typeDesc !== null) {
+ if (!is_object($this->typeDesc)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('typeDesc', TType::STRUCT, 2);
+ $xfer += $this->typeDesc->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->position !== null) {
+ $xfer += $output->writeFieldBegin('position', TType::I32, 3);
+ $xfer += $output->writeI32($this->position);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->comment !== null) {
+ $xfer += $output->writeFieldBegin('comment', TType::STRING, 4);
+ $xfer += $output->writeString($this->comment);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TTableSchema {
+ static $_TSPEC;
+
+ /**
+ * @var \TColumnDesc[]
+ */
+ public $columns = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'columns',
+ 'type' => TType::LST,
+ 'etype' => TType::STRUCT,
+ 'elem' => array(
+ 'type' => TType::STRUCT,
+ 'class' => '\TColumnDesc',
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['columns'])) {
+ $this->columns = $vals['columns'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TTableSchema';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->columns = array();
+ $_size34 = 0;
+ $_etype37 = 0;
+ $xfer += $input->readListBegin($_etype37, $_size34);
+ for ($_i38 = 0; $_i38 < $_size34; ++$_i38)
+ {
+ $elem39 = null;
+ $elem39 = new \TColumnDesc();
+ $xfer += $elem39->read($input);
+ $this->columns []= $elem39;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TTableSchema');
+ if ($this->columns !== null) {
+ if (!is_array($this->columns)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('columns', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::STRUCT, count($this->columns));
+ {
+ foreach ($this->columns as $iter40)
+ {
+ $xfer += $iter40->write($output);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TBoolValue {
+ static $_TSPEC;
+
+ /**
+ * @var bool
+ */
+ public $value = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'value',
+ 'type' => TType::BOOL,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['value'])) {
+ $this->value = $vals['value'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TBoolValue';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::BOOL) {
+ $xfer += $input->readBool($this->value);
+ } 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('TBoolValue');
+ if ($this->value !== null) {
+ $xfer += $output->writeFieldBegin('value', TType::BOOL, 1);
+ $xfer += $output->writeBool($this->value);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TByteValue {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $value = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'value',
+ 'type' => TType::BYTE,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['value'])) {
+ $this->value = $vals['value'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TByteValue';
+ }
+
+ 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::BYTE) {
+ $xfer += $input->readByte($this->value);
+ } 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('TByteValue');
+ if ($this->value !== null) {
+ $xfer += $output->writeFieldBegin('value', TType::BYTE, 1);
+ $xfer += $output->writeByte($this->value);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TI16Value {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $value = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'value',
+ 'type' => TType::I16,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['value'])) {
+ $this->value = $vals['value'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TI16Value';
+ }
+
+ 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::I16) {
+ $xfer += $input->readI16($this->value);
+ } 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('TI16Value');
+ if ($this->value !== null) {
+ $xfer += $output->writeFieldBegin('value', TType::I16, 1);
+ $xfer += $output->writeI16($this->value);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TI32Value {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $value = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'value',
+ 'type' => TType::I32,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['value'])) {
+ $this->value = $vals['value'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TI32Value';
+ }
+
+ 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::I32) {
+ $xfer += $input->readI32($this->value);
+ } 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('TI32Value');
+ if ($this->value !== null) {
+ $xfer += $output->writeFieldBegin('value', TType::I32, 1);
+ $xfer += $output->writeI32($this->value);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TI64Value {
+ static $_TSPEC;
+
+ /**
+ * @var int
+ */
+ public $value = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'value',
+ 'type' => TType::I64,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['value'])) {
+ $this->value = $vals['value'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TI64Value';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::I64) {
+ $xfer += $input->readI64($this->value);
+ } 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('TI64Value');
+ if ($this->value !== null) {
+ $xfer += $output->writeFieldBegin('value', TType::I64, 1);
+ $xfer += $output->writeI64($this->value);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TDoubleValue {
+ static $_TSPEC;
+
+ /**
+ * @var double
+ */
+ public $value = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'value',
+ 'type' => TType::DOUBLE,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['value'])) {
+ $this->value = $vals['value'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TDoubleValue';
+ }
+
+ 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::DOUBLE) {
+ $xfer += $input->readDouble($this->value);
+ } 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('TDoubleValue');
+ if ($this->value !== null) {
+ $xfer += $output->writeFieldBegin('value', TType::DOUBLE, 1);
+ $xfer += $output->writeDouble($this->value);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TStringValue {
+ static $_TSPEC;
+
+ /**
+ * @var string
+ */
+ public $value = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'value',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['value'])) {
+ $this->value = $vals['value'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TStringValue';
+ }
+
+ 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->value);
+ } 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('TStringValue');
+ if ($this->value !== null) {
+ $xfer += $output->writeFieldBegin('value', TType::STRING, 1);
+ $xfer += $output->writeString($this->value);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TColumnValue {
+ static $_TSPEC;
+
+ /**
+ * @var \TBoolValue
+ */
+ public $boolVal = null;
+ /**
+ * @var \TByteValue
+ */
+ public $byteVal = null;
+ /**
+ * @var \TI16Value
+ */
+ public $i16Val = null;
+ /**
+ * @var \TI32Value
+ */
+ public $i32Val = null;
+ /**
+ * @var \TI64Value
+ */
+ public $i64Val = null;
+ /**
+ * @var \TDoubleValue
+ */
+ public $doubleVal = null;
+ /**
+ * @var \TStringValue
+ */
+ public $stringVal = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'boolVal',
+ 'type' => TType::STRUCT,
+ 'class' => '\TBoolValue',
+ ),
+ 2 => array(
+ 'var' => 'byteVal',
+ 'type' => TType::STRUCT,
+ 'class' => '\TByteValue',
+ ),
+ 3 => array(
+ 'var' => 'i16Val',
+ 'type' => TType::STRUCT,
+ 'class' => '\TI16Value',
+ ),
+ 4 => array(
+ 'var' => 'i32Val',
+ 'type' => TType::STRUCT,
+ 'class' => '\TI32Value',
+ ),
+ 5 => array(
+ 'var' => 'i64Val',
+ 'type' => TType::STRUCT,
+ 'class' => '\TI64Value',
+ ),
+ 6 => array(
+ 'var' => 'doubleVal',
+ 'type' => TType::STRUCT,
+ 'class' => '\TDoubleValue',
+ ),
+ 7 => array(
+ 'var' => 'stringVal',
+ 'type' => TType::STRUCT,
+ 'class' => '\TStringValue',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['boolVal'])) {
+ $this->boolVal = $vals['boolVal'];
+ }
+ if (isset($vals['byteVal'])) {
+ $this->byteVal = $vals['byteVal'];
+ }
+ if (isset($vals['i16Val'])) {
+ $this->i16Val = $vals['i16Val'];
+ }
+ if (isset($vals['i32Val'])) {
+ $this->i32Val = $vals['i32Val'];
+ }
+ if (isset($vals['i64Val'])) {
+ $this->i64Val = $vals['i64Val'];
+ }
+ if (isset($vals['doubleVal'])) {
+ $this->doubleVal = $vals['doubleVal'];
+ }
+ if (isset($vals['stringVal'])) {
+ $this->stringVal = $vals['stringVal'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TColumnValue';
+ }
+
+ 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->boolVal = new \TBoolValue();
+ $xfer += $this->boolVal->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->byteVal = new \TByteValue();
+ $xfer += $this->byteVal->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 3:
+ if ($ftype == TType::STRUCT) {
+ $this->i16Val = new \TI16Value();
+ $xfer += $this->i16Val->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 4:
+ if ($ftype == TType::STRUCT) {
+ $this->i32Val = new \TI32Value();
+ $xfer += $this->i32Val->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 5:
+ if ($ftype == TType::STRUCT) {
+ $this->i64Val = new \TI64Value();
+ $xfer += $this->i64Val->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 6:
+ if ($ftype == TType::STRUCT) {
+ $this->doubleVal = new \TDoubleValue();
+ $xfer += $this->doubleVal->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 7:
+ if ($ftype == TType::STRUCT) {
+ $this->stringVal = new \TStringValue();
+ $xfer += $this->stringVal->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('TColumnValue');
+ if ($this->boolVal !== null) {
+ if (!is_object($this->boolVal)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('boolVal', TType::STRUCT, 1);
+ $xfer += $this->boolVal->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->byteVal !== null) {
+ if (!is_object($this->byteVal)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('byteVal', TType::STRUCT, 2);
+ $xfer += $this->byteVal->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->i16Val !== null) {
+ if (!is_object($this->i16Val)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('i16Val', TType::STRUCT, 3);
+ $xfer += $this->i16Val->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->i32Val !== null) {
+ if (!is_object($this->i32Val)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('i32Val', TType::STRUCT, 4);
+ $xfer += $this->i32Val->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->i64Val !== null) {
+ if (!is_object($this->i64Val)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('i64Val', TType::STRUCT, 5);
+ $xfer += $this->i64Val->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->doubleVal !== null) {
+ if (!is_object($this->doubleVal)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('doubleVal', TType::STRUCT, 6);
+ $xfer += $this->doubleVal->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->stringVal !== null) {
+ if (!is_object($this->stringVal)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('stringVal', TType::STRUCT, 7);
+ $xfer += $this->stringVal->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TRow {
+ static $_TSPEC;
+
+ /**
+ * @var \TColumnValue[]
+ */
+ public $colVals = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'colVals',
+ 'type' => TType::LST,
+ 'etype' => TType::STRUCT,
+ 'elem' => array(
+ 'type' => TType::STRUCT,
+ 'class' => '\TColumnValue',
+ ),
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['colVals'])) {
+ $this->colVals = $vals['colVals'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TRow';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->colVals = array();
+ $_size41 = 0;
+ $_etype44 = 0;
+ $xfer += $input->readListBegin($_etype44, $_size41);
+ for ($_i45 = 0; $_i45 < $_size41; ++$_i45)
+ {
+ $elem46 = null;
+ $elem46 = new \TColumnValue();
+ $xfer += $elem46->read($input);
+ $this->colVals []= $elem46;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TRow');
+ if ($this->colVals !== null) {
+ if (!is_array($this->colVals)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('colVals', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::STRUCT, count($this->colVals));
+ {
+ foreach ($this->colVals as $iter47)
+ {
+ $xfer += $iter47->write($output);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TBoolColumn {
+ static $_TSPEC;
+
+ /**
+ * @var bool[]
+ */
+ public $values = null;
+ /**
+ * @var string
+ */
+ public $nulls = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'values',
+ 'type' => TType::LST,
+ 'etype' => TType::BOOL,
+ 'elem' => array(
+ 'type' => TType::BOOL,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'nulls',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
+ }
+ if (isset($vals['nulls'])) {
+ $this->nulls = $vals['nulls'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TBoolColumn';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->values = array();
+ $_size48 = 0;
+ $_etype51 = 0;
+ $xfer += $input->readListBegin($_etype51, $_size48);
+ for ($_i52 = 0; $_i52 < $_size48; ++$_i52)
+ {
+ $elem53 = null;
+ $xfer += $input->readBool($elem53);
+ $this->values []= $elem53;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->nulls);
+ } 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('TBoolColumn');
+ if ($this->values !== null) {
+ if (!is_array($this->values)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('values', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::BOOL, count($this->values));
+ {
+ foreach ($this->values as $iter54)
+ {
+ $xfer += $output->writeBool($iter54);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->nulls !== null) {
+ $xfer += $output->writeFieldBegin('nulls', TType::STRING, 2);
+ $xfer += $output->writeString($this->nulls);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TByteColumn {
+ static $_TSPEC;
+
+ /**
+ * @var int[]
+ */
+ public $values = null;
+ /**
+ * @var string
+ */
+ public $nulls = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'values',
+ 'type' => TType::LST,
+ 'etype' => TType::BYTE,
+ 'elem' => array(
+ 'type' => TType::BYTE,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'nulls',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
+ }
+ if (isset($vals['nulls'])) {
+ $this->nulls = $vals['nulls'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TByteColumn';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->values = array();
+ $_size55 = 0;
+ $_etype58 = 0;
+ $xfer += $input->readListBegin($_etype58, $_size55);
+ for ($_i59 = 0; $_i59 < $_size55; ++$_i59)
+ {
+ $elem60 = null;
+ $xfer += $input->readByte($elem60);
+ $this->values []= $elem60;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->nulls);
+ } 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('TByteColumn');
+ if ($this->values !== null) {
+ if (!is_array($this->values)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('values', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::BYTE, count($this->values));
+ {
+ foreach ($this->values as $iter61)
+ {
+ $xfer += $output->writeByte($iter61);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->nulls !== null) {
+ $xfer += $output->writeFieldBegin('nulls', TType::STRING, 2);
+ $xfer += $output->writeString($this->nulls);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TI16Column {
+ static $_TSPEC;
+
+ /**
+ * @var int[]
+ */
+ public $values = null;
+ /**
+ * @var string
+ */
+ public $nulls = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'values',
+ 'type' => TType::LST,
+ 'etype' => TType::I16,
+ 'elem' => array(
+ 'type' => TType::I16,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'nulls',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
+ }
+ if (isset($vals['nulls'])) {
+ $this->nulls = $vals['nulls'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TI16Column';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->values = array();
+ $_size62 = 0;
+ $_etype65 = 0;
+ $xfer += $input->readListBegin($_etype65, $_size62);
+ for ($_i66 = 0; $_i66 < $_size62; ++$_i66)
+ {
+ $elem67 = null;
+ $xfer += $input->readI16($elem67);
+ $this->values []= $elem67;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->nulls);
+ } 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('TI16Column');
+ if ($this->values !== null) {
+ if (!is_array($this->values)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('values', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::I16, count($this->values));
+ {
+ foreach ($this->values as $iter68)
+ {
+ $xfer += $output->writeI16($iter68);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->nulls !== null) {
+ $xfer += $output->writeFieldBegin('nulls', TType::STRING, 2);
+ $xfer += $output->writeString($this->nulls);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TI32Column {
+ static $_TSPEC;
+
+ /**
+ * @var int[]
+ */
+ public $values = null;
+ /**
+ * @var string
+ */
+ public $nulls = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'values',
+ 'type' => TType::LST,
+ 'etype' => TType::I32,
+ 'elem' => array(
+ 'type' => TType::I32,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'nulls',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
+ }
+ if (isset($vals['nulls'])) {
+ $this->nulls = $vals['nulls'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TI32Column';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->values = array();
+ $_size69 = 0;
+ $_etype72 = 0;
+ $xfer += $input->readListBegin($_etype72, $_size69);
+ for ($_i73 = 0; $_i73 < $_size69; ++$_i73)
+ {
+ $elem74 = null;
+ $xfer += $input->readI32($elem74);
+ $this->values []= $elem74;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->nulls);
+ } 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('TI32Column');
+ if ($this->values !== null) {
+ if (!is_array($this->values)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('values', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::I32, count($this->values));
+ {
+ foreach ($this->values as $iter75)
+ {
+ $xfer += $output->writeI32($iter75);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->nulls !== null) {
+ $xfer += $output->writeFieldBegin('nulls', TType::STRING, 2);
+ $xfer += $output->writeString($this->nulls);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TI64Column {
+ static $_TSPEC;
+
+ /**
+ * @var int[]
+ */
+ public $values = null;
+ /**
+ * @var string
+ */
+ public $nulls = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'values',
+ 'type' => TType::LST,
+ 'etype' => TType::I64,
+ 'elem' => array(
+ 'type' => TType::I64,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'nulls',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
+ }
+ if (isset($vals['nulls'])) {
+ $this->nulls = $vals['nulls'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TI64Column';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->values = array();
+ $_size76 = 0;
+ $_etype79 = 0;
+ $xfer += $input->readListBegin($_etype79, $_size76);
+ for ($_i80 = 0; $_i80 < $_size76; ++$_i80)
+ {
+ $elem81 = null;
+ $xfer += $input->readI64($elem81);
+ $this->values []= $elem81;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->nulls);
+ } 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('TI64Column');
+ if ($this->values !== null) {
+ if (!is_array($this->values)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('values', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::I64, count($this->values));
+ {
+ foreach ($this->values as $iter82)
+ {
+ $xfer += $output->writeI64($iter82);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->nulls !== null) {
+ $xfer += $output->writeFieldBegin('nulls', TType::STRING, 2);
+ $xfer += $output->writeString($this->nulls);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TDoubleColumn {
+ static $_TSPEC;
+
+ /**
+ * @var double[]
+ */
+ public $values = null;
+ /**
+ * @var string
+ */
+ public $nulls = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'values',
+ 'type' => TType::LST,
+ 'etype' => TType::DOUBLE,
+ 'elem' => array(
+ 'type' => TType::DOUBLE,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'nulls',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
+ }
+ if (isset($vals['nulls'])) {
+ $this->nulls = $vals['nulls'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TDoubleColumn';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->values = array();
+ $_size83 = 0;
+ $_etype86 = 0;
+ $xfer += $input->readListBegin($_etype86, $_size83);
+ for ($_i87 = 0; $_i87 < $_size83; ++$_i87)
+ {
+ $elem88 = null;
+ $xfer += $input->readDouble($elem88);
+ $this->values []= $elem88;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->nulls);
+ } 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('TDoubleColumn');
+ if ($this->values !== null) {
+ if (!is_array($this->values)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('values', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::DOUBLE, count($this->values));
+ {
+ foreach ($this->values as $iter89)
+ {
+ $xfer += $output->writeDouble($iter89);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->nulls !== null) {
+ $xfer += $output->writeFieldBegin('nulls', TType::STRING, 2);
+ $xfer += $output->writeString($this->nulls);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TStringColumn {
+ static $_TSPEC;
+
+ /**
+ * @var string[]
+ */
+ public $values = null;
+ /**
+ * @var string
+ */
+ public $nulls = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'values',
+ 'type' => TType::LST,
+ 'etype' => TType::STRING,
+ 'elem' => array(
+ 'type' => TType::STRING,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'nulls',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
+ }
+ if (isset($vals['nulls'])) {
+ $this->nulls = $vals['nulls'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TStringColumn';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->values = array();
+ $_size90 = 0;
+ $_etype93 = 0;
+ $xfer += $input->readListBegin($_etype93, $_size90);
+ for ($_i94 = 0; $_i94 < $_size90; ++$_i94)
+ {
+ $elem95 = null;
+ $xfer += $input->readString($elem95);
+ $this->values []= $elem95;
+ }
+ $xfer += $input->readListEnd();
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->nulls);
+ } 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('TStringColumn');
+ if ($this->values !== null) {
+ if (!is_array($this->values)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('values', TType::LST, 1);
+ {
+ $output->writeListBegin(TType::STRING, count($this->values));
+ {
+ foreach ($this->values as $iter96)
+ {
+ $xfer += $output->writeString($iter96);
+ }
+ }
+ $output->writeListEnd();
+ }
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->nulls !== null) {
+ $xfer += $output->writeFieldBegin('nulls', TType::STRING, 2);
+ $xfer += $output->writeString($this->nulls);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TBinaryColumn {
+ static $_TSPEC;
+
+ /**
+ * @var string[]
+ */
+ public $values = null;
+ /**
+ * @var string
+ */
+ public $nulls = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'values',
+ 'type' => TType::LST,
+ 'etype' => TType::STRING,
+ 'elem' => array(
+ 'type' => TType::STRING,
+ ),
+ ),
+ 2 => array(
+ 'var' => 'nulls',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
+ }
+ if (isset($vals['nulls'])) {
+ $this->nulls = $vals['nulls'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TBinaryColumn';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::LST) {
+ $this->values = array();
+

<TRUNCATED>

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 77 of 102 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedJan 8, '16 at 12:19a
activeJan 11, '16 at 8:25a
posts102
users1
websitehive.apache.org

1 user in discussion

Vgumashta: 102 posts

People

Translate

site design / logo © 2021 Grokbase