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>