[25/51] [partial] hive git commit: HIVE-12442: Refactor/repackage HiveServer2's Thrift code so that it can be used in the tasks (Rohit Dholakia reviewed by Vaibhav Gumashta)

[vg...@apache.org]

http://git-wip-us.apache.org/repos/asf/hive/blob/2542f5cc/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..d5ac168
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-php/Types.php
@@ -0,0 +1,9040 @@
+<?php
+namespace ;
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.2)
+ *
+ * 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>