[14/51] [partial] hive git commit: Revert "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/a28f6cd8/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
----------------------------------------------------------------------
diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp b/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
new file mode 100644
index 0000000..b852379
--- /dev/null
+++ b/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
@@ -0,0 +1,9231 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "TCLIService_types.h"
+
+#include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
+
+namespace apache { namespace hive { namespace service { namespace cli { namespace thrift {
+
+int _kTProtocolVersionValues[] = {
+  TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V1,
+  TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V2,
+  TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V3,
+  TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V4,
+  TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V5,
+  TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V6,
+  TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V7,
+  TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V8
+};
+const char* _kTProtocolVersionNames[] = {
+  "HIVE_CLI_SERVICE_PROTOCOL_V1",
+  "HIVE_CLI_SERVICE_PROTOCOL_V2",
+  "HIVE_CLI_SERVICE_PROTOCOL_V3",
+  "HIVE_CLI_SERVICE_PROTOCOL_V4",
+  "HIVE_CLI_SERVICE_PROTOCOL_V5",
+  "HIVE_CLI_SERVICE_PROTOCOL_V6",
+  "HIVE_CLI_SERVICE_PROTOCOL_V7",
+  "HIVE_CLI_SERVICE_PROTOCOL_V8"
+};
+const std::map<int, const char*> _TProtocolVersion_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kTProtocolVersionValues, _kTProtocolVersionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTTypeIdValues[] = {
+  TTypeId::BOOLEAN_TYPE,
+  TTypeId::TINYINT_TYPE,
+  TTypeId::SMALLINT_TYPE,
+  TTypeId::INT_TYPE,
+  TTypeId::BIGINT_TYPE,
+  TTypeId::FLOAT_TYPE,
+  TTypeId::DOUBLE_TYPE,
+  TTypeId::STRING_TYPE,
+  TTypeId::TIMESTAMP_TYPE,
+  TTypeId::BINARY_TYPE,
+  TTypeId::ARRAY_TYPE,
+  TTypeId::MAP_TYPE,
+  TTypeId::STRUCT_TYPE,
+  TTypeId::UNION_TYPE,
+  TTypeId::USER_DEFINED_TYPE,
+  TTypeId::DECIMAL_TYPE,
+  TTypeId::NULL_TYPE,
+  TTypeId::DATE_TYPE,
+  TTypeId::VARCHAR_TYPE,
+  TTypeId::CHAR_TYPE,
+  TTypeId::INTERVAL_YEAR_MONTH_TYPE,
+  TTypeId::INTERVAL_DAY_TIME_TYPE
+};
+const char* _kTTypeIdNames[] = {
+  "BOOLEAN_TYPE",
+  "TINYINT_TYPE",
+  "SMALLINT_TYPE",
+  "INT_TYPE",
+  "BIGINT_TYPE",
+  "FLOAT_TYPE",
+  "DOUBLE_TYPE",
+  "STRING_TYPE",
+  "TIMESTAMP_TYPE",
+  "BINARY_TYPE",
+  "ARRAY_TYPE",
+  "MAP_TYPE",
+  "STRUCT_TYPE",
+  "UNION_TYPE",
+  "USER_DEFINED_TYPE",
+  "DECIMAL_TYPE",
+  "NULL_TYPE",
+  "DATE_TYPE",
+  "VARCHAR_TYPE",
+  "CHAR_TYPE",
+  "INTERVAL_YEAR_MONTH_TYPE",
+  "INTERVAL_DAY_TIME_TYPE"
+};
+const std::map<int, const char*> _TTypeId_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(22, _kTTypeIdValues, _kTTypeIdNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTStatusCodeValues[] = {
+  TStatusCode::SUCCESS_STATUS,
+  TStatusCode::SUCCESS_WITH_INFO_STATUS,
+  TStatusCode::STILL_EXECUTING_STATUS,
+  TStatusCode::ERROR_STATUS,
+  TStatusCode::INVALID_HANDLE_STATUS
+};
+const char* _kTStatusCodeNames[] = {
+  "SUCCESS_STATUS",
+  "SUCCESS_WITH_INFO_STATUS",
+  "STILL_EXECUTING_STATUS",
+  "ERROR_STATUS",
+  "INVALID_HANDLE_STATUS"
+};
+const std::map<int, const char*> _TStatusCode_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kTStatusCodeValues, _kTStatusCodeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTOperationStateValues[] = {
+  TOperationState::INITIALIZED_STATE,
+  TOperationState::RUNNING_STATE,
+  TOperationState::FINISHED_STATE,
+  TOperationState::CANCELED_STATE,
+  TOperationState::CLOSED_STATE,
+  TOperationState::ERROR_STATE,
+  TOperationState::UKNOWN_STATE,
+  TOperationState::PENDING_STATE
+};
+const char* _kTOperationStateNames[] = {
+  "INITIALIZED_STATE",
+  "RUNNING_STATE",
+  "FINISHED_STATE",
+  "CANCELED_STATE",
+  "CLOSED_STATE",
+  "ERROR_STATE",
+  "UKNOWN_STATE",
+  "PENDING_STATE"
+};
+const std::map<int, const char*> _TOperationState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kTOperationStateValues, _kTOperationStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTOperationTypeValues[] = {
+  TOperationType::EXECUTE_STATEMENT,
+  TOperationType::GET_TYPE_INFO,
+  TOperationType::GET_CATALOGS,
+  TOperationType::GET_SCHEMAS,
+  TOperationType::GET_TABLES,
+  TOperationType::GET_TABLE_TYPES,
+  TOperationType::GET_COLUMNS,
+  TOperationType::GET_FUNCTIONS,
+  TOperationType::UNKNOWN
+};
+const char* _kTOperationTypeNames[] = {
+  "EXECUTE_STATEMENT",
+  "GET_TYPE_INFO",
+  "GET_CATALOGS",
+  "GET_SCHEMAS",
+  "GET_TABLES",
+  "GET_TABLE_TYPES",
+  "GET_COLUMNS",
+  "GET_FUNCTIONS",
+  "UNKNOWN"
+};
+const std::map<int, const char*> _TOperationType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(9, _kTOperationTypeValues, _kTOperationTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTGetInfoTypeValues[] = {
+  TGetInfoType::CLI_MAX_DRIVER_CONNECTIONS,
+  TGetInfoType::CLI_MAX_CONCURRENT_ACTIVITIES,
+  TGetInfoType::CLI_DATA_SOURCE_NAME,
+  TGetInfoType::CLI_FETCH_DIRECTION,
+  TGetInfoType::CLI_SERVER_NAME,
+  TGetInfoType::CLI_SEARCH_PATTERN_ESCAPE,
+  TGetInfoType::CLI_DBMS_NAME,
+  TGetInfoType::CLI_DBMS_VER,
+  TGetInfoType::CLI_ACCESSIBLE_TABLES,
+  TGetInfoType::CLI_ACCESSIBLE_PROCEDURES,
+  TGetInfoType::CLI_CURSOR_COMMIT_BEHAVIOR,
+  TGetInfoType::CLI_DATA_SOURCE_READ_ONLY,
+  TGetInfoType::CLI_DEFAULT_TXN_ISOLATION,
+  TGetInfoType::CLI_IDENTIFIER_CASE,
+  TGetInfoType::CLI_IDENTIFIER_QUOTE_CHAR,
+  TGetInfoType::CLI_MAX_COLUMN_NAME_LEN,
+  TGetInfoType::CLI_MAX_CURSOR_NAME_LEN,
+  TGetInfoType::CLI_MAX_SCHEMA_NAME_LEN,
+  TGetInfoType::CLI_MAX_CATALOG_NAME_LEN,
+  TGetInfoType::CLI_MAX_TABLE_NAME_LEN,
+  TGetInfoType::CLI_SCROLL_CONCURRENCY,
+  TGetInfoType::CLI_TXN_CAPABLE,
+  TGetInfoType::CLI_USER_NAME,
+  TGetInfoType::CLI_TXN_ISOLATION_OPTION,
+  TGetInfoType::CLI_INTEGRITY,
+  TGetInfoType::CLI_GETDATA_EXTENSIONS,
+  TGetInfoType::CLI_NULL_COLLATION,
+  TGetInfoType::CLI_ALTER_TABLE,
+  TGetInfoType::CLI_ORDER_BY_COLUMNS_IN_SELECT,
+  TGetInfoType::CLI_SPECIAL_CHARACTERS,
+  TGetInfoType::CLI_MAX_COLUMNS_IN_GROUP_BY,
+  TGetInfoType::CLI_MAX_COLUMNS_IN_INDEX,
+  TGetInfoType::CLI_MAX_COLUMNS_IN_ORDER_BY,
+  TGetInfoType::CLI_MAX_COLUMNS_IN_SELECT,
+  TGetInfoType::CLI_MAX_COLUMNS_IN_TABLE,
+  TGetInfoType::CLI_MAX_INDEX_SIZE,
+  TGetInfoType::CLI_MAX_ROW_SIZE,
+  TGetInfoType::CLI_MAX_STATEMENT_LEN,
+  TGetInfoType::CLI_MAX_TABLES_IN_SELECT,
+  TGetInfoType::CLI_MAX_USER_NAME_LEN,
+  TGetInfoType::CLI_OJ_CAPABILITIES,
+  TGetInfoType::CLI_XOPEN_CLI_YEAR,
+  TGetInfoType::CLI_CURSOR_SENSITIVITY,
+  TGetInfoType::CLI_DESCRIBE_PARAMETER,
+  TGetInfoType::CLI_CATALOG_NAME,
+  TGetInfoType::CLI_COLLATION_SEQ,
+  TGetInfoType::CLI_MAX_IDENTIFIER_LEN
+};
+const char* _kTGetInfoTypeNames[] = {
+  "CLI_MAX_DRIVER_CONNECTIONS",
+  "CLI_MAX_CONCURRENT_ACTIVITIES",
+  "CLI_DATA_SOURCE_NAME",
+  "CLI_FETCH_DIRECTION",
+  "CLI_SERVER_NAME",
+  "CLI_SEARCH_PATTERN_ESCAPE",
+  "CLI_DBMS_NAME",
+  "CLI_DBMS_VER",
+  "CLI_ACCESSIBLE_TABLES",
+  "CLI_ACCESSIBLE_PROCEDURES",
+  "CLI_CURSOR_COMMIT_BEHAVIOR",
+  "CLI_DATA_SOURCE_READ_ONLY",
+  "CLI_DEFAULT_TXN_ISOLATION",
+  "CLI_IDENTIFIER_CASE",
+  "CLI_IDENTIFIER_QUOTE_CHAR",
+  "CLI_MAX_COLUMN_NAME_LEN",
+  "CLI_MAX_CURSOR_NAME_LEN",
+  "CLI_MAX_SCHEMA_NAME_LEN",
+  "CLI_MAX_CATALOG_NAME_LEN",
+  "CLI_MAX_TABLE_NAME_LEN",
+  "CLI_SCROLL_CONCURRENCY",
+  "CLI_TXN_CAPABLE",
+  "CLI_USER_NAME",
+  "CLI_TXN_ISOLATION_OPTION",
+  "CLI_INTEGRITY",
+  "CLI_GETDATA_EXTENSIONS",
+  "CLI_NULL_COLLATION",
+  "CLI_ALTER_TABLE",
+  "CLI_ORDER_BY_COLUMNS_IN_SELECT",
+  "CLI_SPECIAL_CHARACTERS",
+  "CLI_MAX_COLUMNS_IN_GROUP_BY",
+  "CLI_MAX_COLUMNS_IN_INDEX",
+  "CLI_MAX_COLUMNS_IN_ORDER_BY",
+  "CLI_MAX_COLUMNS_IN_SELECT",
+  "CLI_MAX_COLUMNS_IN_TABLE",
+  "CLI_MAX_INDEX_SIZE",
+  "CLI_MAX_ROW_SIZE",
+  "CLI_MAX_STATEMENT_LEN",
+  "CLI_MAX_TABLES_IN_SELECT",
+  "CLI_MAX_USER_NAME_LEN",
+  "CLI_OJ_CAPABILITIES",
+  "CLI_XOPEN_CLI_YEAR",
+  "CLI_CURSOR_SENSITIVITY",
+  "CLI_DESCRIBE_PARAMETER",
+  "CLI_CATALOG_NAME",
+  "CLI_COLLATION_SEQ",
+  "CLI_MAX_IDENTIFIER_LEN"
+};
+const std::map<int, const char*> _TGetInfoType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(47, _kTGetInfoTypeValues, _kTGetInfoTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTFetchOrientationValues[] = {
+  TFetchOrientation::FETCH_NEXT,
+  TFetchOrientation::FETCH_PRIOR,
+  TFetchOrientation::FETCH_RELATIVE,
+  TFetchOrientation::FETCH_ABSOLUTE,
+  TFetchOrientation::FETCH_FIRST,
+  TFetchOrientation::FETCH_LAST
+};
+const char* _kTFetchOrientationNames[] = {
+  "FETCH_NEXT",
+  "FETCH_PRIOR",
+  "FETCH_RELATIVE",
+  "FETCH_ABSOLUTE",
+  "FETCH_FIRST",
+  "FETCH_LAST"
+};
+const std::map<int, const char*> _TFetchOrientation_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kTFetchOrientationValues, _kTFetchOrientationNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+
+TTypeQualifierValue::~TTypeQualifierValue() throw() {
+}
+
+
+void TTypeQualifierValue::__set_i32Value(const int32_t val) {
+  this->i32Value = val;
+__isset.i32Value = true;
+}
+
+void TTypeQualifierValue::__set_stringValue(const std::string& val) {
+  this->stringValue = val;
+__isset.stringValue = true;
+}
+
+uint32_t TTypeQualifierValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->i32Value);
+          this->__isset.i32Value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->stringValue);
+          this->__isset.stringValue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TTypeQualifierValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TTypeQualifierValue");
+
+  if (this->__isset.i32Value) {
+    xfer += oprot->writeFieldBegin("i32Value", ::apache::thrift::protocol::T_I32, 1);
+    xfer += oprot->writeI32(this->i32Value);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.stringValue) {
+    xfer += oprot->writeFieldBegin("stringValue", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->stringValue);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TTypeQualifierValue &a, TTypeQualifierValue &b) {
+  using ::std::swap;
+  swap(a.i32Value, b.i32Value);
+  swap(a.stringValue, b.stringValue);
+  swap(a.__isset, b.__isset);
+}
+
+TTypeQualifierValue::TTypeQualifierValue(const TTypeQualifierValue& other0) {
+  i32Value = other0.i32Value;
+  stringValue = other0.stringValue;
+  __isset = other0.__isset;
+}
+TTypeQualifierValue& TTypeQualifierValue::operator=(const TTypeQualifierValue& other1) {
+  i32Value = other1.i32Value;
+  stringValue = other1.stringValue;
+  __isset = other1.__isset;
+  return *this;
+}
+void TTypeQualifierValue::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TTypeQualifierValue(";
+  out << "i32Value="; (__isset.i32Value ? (out << to_string(i32Value)) : (out << "<null>"));
+  out << ", " << "stringValue="; (__isset.stringValue ? (out << to_string(stringValue)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TTypeQualifiers::~TTypeQualifiers() throw() {
+}
+
+
+void TTypeQualifiers::__set_qualifiers(const std::map<std::string, TTypeQualifierValue> & val) {
+  this->qualifiers = val;
+}
+
+uint32_t TTypeQualifiers::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_qualifiers = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->qualifiers.clear();
+            uint32_t _size2;
+            ::apache::thrift::protocol::TType _ktype3;
+            ::apache::thrift::protocol::TType _vtype4;
+            xfer += iprot->readMapBegin(_ktype3, _vtype4, _size2);
+            uint32_t _i6;
+            for (_i6 = 0; _i6 < _size2; ++_i6)
+            {
+              std::string _key7;
+              xfer += iprot->readString(_key7);
+              TTypeQualifierValue& _val8 = this->qualifiers[_key7];
+              xfer += _val8.read(iprot);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_qualifiers = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_qualifiers)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TTypeQualifiers::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TTypeQualifiers");
+
+  xfer += oprot->writeFieldBegin("qualifiers", ::apache::thrift::protocol::T_MAP, 1);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->qualifiers.size()));
+    std::map<std::string, TTypeQualifierValue> ::const_iterator _iter9;
+    for (_iter9 = this->qualifiers.begin(); _iter9 != this->qualifiers.end(); ++_iter9)
+    {
+      xfer += oprot->writeString(_iter9->first);
+      xfer += _iter9->second.write(oprot);
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TTypeQualifiers &a, TTypeQualifiers &b) {
+  using ::std::swap;
+  swap(a.qualifiers, b.qualifiers);
+}
+
+TTypeQualifiers::TTypeQualifiers(const TTypeQualifiers& other10) {
+  qualifiers = other10.qualifiers;
+}
+TTypeQualifiers& TTypeQualifiers::operator=(const TTypeQualifiers& other11) {
+  qualifiers = other11.qualifiers;
+  return *this;
+}
+void TTypeQualifiers::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TTypeQualifiers(";
+  out << "qualifiers=" << to_string(qualifiers);
+  out << ")";
+}
+
+
+TPrimitiveTypeEntry::~TPrimitiveTypeEntry() throw() {
+}
+
+
+void TPrimitiveTypeEntry::__set_type(const TTypeId::type val) {
+  this->type = val;
+}
+
+void TPrimitiveTypeEntry::__set_typeQualifiers(const TTypeQualifiers& val) {
+  this->typeQualifiers = val;
+__isset.typeQualifiers = true;
+}
+
+uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_type = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast12;
+          xfer += iprot->readI32(ecast12);
+          this->type = (TTypeId::type)ecast12;
+          isset_type = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->typeQualifiers.read(iprot);
+          this->__isset.typeQualifiers = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_type)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TPrimitiveTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TPrimitiveTypeEntry");
+
+  xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->type);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.typeQualifiers) {
+    xfer += oprot->writeFieldBegin("typeQualifiers", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->typeQualifiers.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b) {
+  using ::std::swap;
+  swap(a.type, b.type);
+  swap(a.typeQualifiers, b.typeQualifiers);
+  swap(a.__isset, b.__isset);
+}
+
+TPrimitiveTypeEntry::TPrimitiveTypeEntry(const TPrimitiveTypeEntry& other13) {
+  type = other13.type;
+  typeQualifiers = other13.typeQualifiers;
+  __isset = other13.__isset;
+}
+TPrimitiveTypeEntry& TPrimitiveTypeEntry::operator=(const TPrimitiveTypeEntry& other14) {
+  type = other14.type;
+  typeQualifiers = other14.typeQualifiers;
+  __isset = other14.__isset;
+  return *this;
+}
+void TPrimitiveTypeEntry::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TPrimitiveTypeEntry(";
+  out << "type=" << to_string(type);
+  out << ", " << "typeQualifiers="; (__isset.typeQualifiers ? (out << to_string(typeQualifiers)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TArrayTypeEntry::~TArrayTypeEntry() throw() {
+}
+
+
+void TArrayTypeEntry::__set_objectTypePtr(const TTypeEntryPtr val) {
+  this->objectTypePtr = val;
+}
+
+uint32_t TArrayTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_objectTypePtr = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->objectTypePtr);
+          isset_objectTypePtr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_objectTypePtr)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TArrayTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TArrayTypeEntry");
+
+  xfer += oprot->writeFieldBegin("objectTypePtr", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32(this->objectTypePtr);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TArrayTypeEntry &a, TArrayTypeEntry &b) {
+  using ::std::swap;
+  swap(a.objectTypePtr, b.objectTypePtr);
+}
+
+TArrayTypeEntry::TArrayTypeEntry(const TArrayTypeEntry& other15) {
+  objectTypePtr = other15.objectTypePtr;
+}
+TArrayTypeEntry& TArrayTypeEntry::operator=(const TArrayTypeEntry& other16) {
+  objectTypePtr = other16.objectTypePtr;
+  return *this;
+}
+void TArrayTypeEntry::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TArrayTypeEntry(";
+  out << "objectTypePtr=" << to_string(objectTypePtr);
+  out << ")";
+}
+
+
+TMapTypeEntry::~TMapTypeEntry() throw() {
+}
+
+
+void TMapTypeEntry::__set_keyTypePtr(const TTypeEntryPtr val) {
+  this->keyTypePtr = val;
+}
+
+void TMapTypeEntry::__set_valueTypePtr(const TTypeEntryPtr val) {
+  this->valueTypePtr = val;
+}
+
+uint32_t TMapTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_keyTypePtr = false;
+  bool isset_valueTypePtr = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->keyTypePtr);
+          isset_keyTypePtr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->valueTypePtr);
+          isset_valueTypePtr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_keyTypePtr)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_valueTypePtr)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TMapTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TMapTypeEntry");
+
+  xfer += oprot->writeFieldBegin("keyTypePtr", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32(this->keyTypePtr);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("valueTypePtr", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32(this->valueTypePtr);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TMapTypeEntry &a, TMapTypeEntry &b) {
+  using ::std::swap;
+  swap(a.keyTypePtr, b.keyTypePtr);
+  swap(a.valueTypePtr, b.valueTypePtr);
+}
+
+TMapTypeEntry::TMapTypeEntry(const TMapTypeEntry& other17) {
+  keyTypePtr = other17.keyTypePtr;
+  valueTypePtr = other17.valueTypePtr;
+}
+TMapTypeEntry& TMapTypeEntry::operator=(const TMapTypeEntry& other18) {
+  keyTypePtr = other18.keyTypePtr;
+  valueTypePtr = other18.valueTypePtr;
+  return *this;
+}
+void TMapTypeEntry::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TMapTypeEntry(";
+  out << "keyTypePtr=" << to_string(keyTypePtr);
+  out << ", " << "valueTypePtr=" << to_string(valueTypePtr);
+  out << ")";
+}
+
+
+TStructTypeEntry::~TStructTypeEntry() throw() {
+}
+
+
+void TStructTypeEntry::__set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) {
+  this->nameToTypePtr = val;
+}
+
+uint32_t TStructTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_nameToTypePtr = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->nameToTypePtr.clear();
+            uint32_t _size19;
+            ::apache::thrift::protocol::TType _ktype20;
+            ::apache::thrift::protocol::TType _vtype21;
+            xfer += iprot->readMapBegin(_ktype20, _vtype21, _size19);
+            uint32_t _i23;
+            for (_i23 = 0; _i23 < _size19; ++_i23)
+            {
+              std::string _key24;
+              xfer += iprot->readString(_key24);
+              TTypeEntryPtr& _val25 = this->nameToTypePtr[_key24];
+              xfer += iprot->readI32(_val25);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_nameToTypePtr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_nameToTypePtr)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TStructTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TStructTypeEntry");
+
+  xfer += oprot->writeFieldBegin("nameToTypePtr", ::apache::thrift::protocol::T_MAP, 1);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->nameToTypePtr.size()));
+    std::map<std::string, TTypeEntryPtr> ::const_iterator _iter26;
+    for (_iter26 = this->nameToTypePtr.begin(); _iter26 != this->nameToTypePtr.end(); ++_iter26)
+    {
+      xfer += oprot->writeString(_iter26->first);
+      xfer += oprot->writeI32(_iter26->second);
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TStructTypeEntry &a, TStructTypeEntry &b) {
+  using ::std::swap;
+  swap(a.nameToTypePtr, b.nameToTypePtr);
+}
+
+TStructTypeEntry::TStructTypeEntry(const TStructTypeEntry& other27) {
+  nameToTypePtr = other27.nameToTypePtr;
+}
+TStructTypeEntry& TStructTypeEntry::operator=(const TStructTypeEntry& other28) {
+  nameToTypePtr = other28.nameToTypePtr;
+  return *this;
+}
+void TStructTypeEntry::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TStructTypeEntry(";
+  out << "nameToTypePtr=" << to_string(nameToTypePtr);
+  out << ")";
+}
+
+
+TUnionTypeEntry::~TUnionTypeEntry() throw() {
+}
+
+
+void TUnionTypeEntry::__set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) {
+  this->nameToTypePtr = val;
+}
+
+uint32_t TUnionTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_nameToTypePtr = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->nameToTypePtr.clear();
+            uint32_t _size29;
+            ::apache::thrift::protocol::TType _ktype30;
+            ::apache::thrift::protocol::TType _vtype31;
+            xfer += iprot->readMapBegin(_ktype30, _vtype31, _size29);
+            uint32_t _i33;
+            for (_i33 = 0; _i33 < _size29; ++_i33)
+            {
+              std::string _key34;
+              xfer += iprot->readString(_key34);
+              TTypeEntryPtr& _val35 = this->nameToTypePtr[_key34];
+              xfer += iprot->readI32(_val35);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_nameToTypePtr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_nameToTypePtr)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TUnionTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TUnionTypeEntry");
+
+  xfer += oprot->writeFieldBegin("nameToTypePtr", ::apache::thrift::protocol::T_MAP, 1);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->nameToTypePtr.size()));
+    std::map<std::string, TTypeEntryPtr> ::const_iterator _iter36;
+    for (_iter36 = this->nameToTypePtr.begin(); _iter36 != this->nameToTypePtr.end(); ++_iter36)
+    {
+      xfer += oprot->writeString(_iter36->first);
+      xfer += oprot->writeI32(_iter36->second);
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TUnionTypeEntry &a, TUnionTypeEntry &b) {
+  using ::std::swap;
+  swap(a.nameToTypePtr, b.nameToTypePtr);
+}
+
+TUnionTypeEntry::TUnionTypeEntry(const TUnionTypeEntry& other37) {
+  nameToTypePtr = other37.nameToTypePtr;
+}
+TUnionTypeEntry& TUnionTypeEntry::operator=(const TUnionTypeEntry& other38) {
+  nameToTypePtr = other38.nameToTypePtr;
+  return *this;
+}
+void TUnionTypeEntry::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TUnionTypeEntry(";
+  out << "nameToTypePtr=" << to_string(nameToTypePtr);
+  out << ")";
+}
+
+
+TUserDefinedTypeEntry::~TUserDefinedTypeEntry() throw() {
+}
+
+
+void TUserDefinedTypeEntry::__set_typeClassName(const std::string& val) {
+  this->typeClassName = val;
+}
+
+uint32_t TUserDefinedTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_typeClassName = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->typeClassName);
+          isset_typeClassName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_typeClassName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TUserDefinedTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TUserDefinedTypeEntry");
+
+  xfer += oprot->writeFieldBegin("typeClassName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->typeClassName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b) {
+  using ::std::swap;
+  swap(a.typeClassName, b.typeClassName);
+}
+
+TUserDefinedTypeEntry::TUserDefinedTypeEntry(const TUserDefinedTypeEntry& other39) {
+  typeClassName = other39.typeClassName;
+}
+TUserDefinedTypeEntry& TUserDefinedTypeEntry::operator=(const TUserDefinedTypeEntry& other40) {
+  typeClassName = other40.typeClassName;
+  return *this;
+}
+void TUserDefinedTypeEntry::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TUserDefinedTypeEntry(";
+  out << "typeClassName=" << to_string(typeClassName);
+  out << ")";
+}
+
+
+TTypeEntry::~TTypeEntry() throw() {
+}
+
+
+void TTypeEntry::__set_primitiveEntry(const TPrimitiveTypeEntry& val) {
+  this->primitiveEntry = val;
+}
+
+void TTypeEntry::__set_arrayEntry(const TArrayTypeEntry& val) {
+  this->arrayEntry = val;
+}
+
+void TTypeEntry::__set_mapEntry(const TMapTypeEntry& val) {
+  this->mapEntry = val;
+}
+
+void TTypeEntry::__set_structEntry(const TStructTypeEntry& val) {
+  this->structEntry = val;
+}
+
+void TTypeEntry::__set_unionEntry(const TUnionTypeEntry& val) {
+  this->unionEntry = val;
+}
+
+void TTypeEntry::__set_userDefinedTypeEntry(const TUserDefinedTypeEntry& val) {
+  this->userDefinedTypeEntry = val;
+}
+
+uint32_t TTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->primitiveEntry.read(iprot);
+          this->__isset.primitiveEntry = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->arrayEntry.read(iprot);
+          this->__isset.arrayEntry = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->mapEntry.read(iprot);
+          this->__isset.mapEntry = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->structEntry.read(iprot);
+          this->__isset.structEntry = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->unionEntry.read(iprot);
+          this->__isset.unionEntry = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userDefinedTypeEntry.read(iprot);
+          this->__isset.userDefinedTypeEntry = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TTypeEntry");
+
+  xfer += oprot->writeFieldBegin("primitiveEntry", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->primitiveEntry.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("arrayEntry", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->arrayEntry.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("mapEntry", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->mapEntry.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("structEntry", ::apache::thrift::protocol::T_STRUCT, 4);
+  xfer += this->structEntry.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("unionEntry", ::apache::thrift::protocol::T_STRUCT, 5);
+  xfer += this->unionEntry.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("userDefinedTypeEntry", ::apache::thrift::protocol::T_STRUCT, 6);
+  xfer += this->userDefinedTypeEntry.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TTypeEntry &a, TTypeEntry &b) {
+  using ::std::swap;
+  swap(a.primitiveEntry, b.primitiveEntry);
+  swap(a.arrayEntry, b.arrayEntry);
+  swap(a.mapEntry, b.mapEntry);
+  swap(a.structEntry, b.structEntry);
+  swap(a.unionEntry, b.unionEntry);
+  swap(a.userDefinedTypeEntry, b.userDefinedTypeEntry);
+  swap(a.__isset, b.__isset);
+}
+
+TTypeEntry::TTypeEntry(const TTypeEntry& other41) {
+  primitiveEntry = other41.primitiveEntry;
+  arrayEntry = other41.arrayEntry;
+  mapEntry = other41.mapEntry;
+  structEntry = other41.structEntry;
+  unionEntry = other41.unionEntry;
+  userDefinedTypeEntry = other41.userDefinedTypeEntry;
+  __isset = other41.__isset;
+}
+TTypeEntry& TTypeEntry::operator=(const TTypeEntry& other42) {
+  primitiveEntry = other42.primitiveEntry;
+  arrayEntry = other42.arrayEntry;
+  mapEntry = other42.mapEntry;
+  structEntry = other42.structEntry;
+  unionEntry = other42.unionEntry;
+  userDefinedTypeEntry = other42.userDefinedTypeEntry;
+  __isset = other42.__isset;
+  return *this;
+}
+void TTypeEntry::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TTypeEntry(";
+  out << "primitiveEntry=" << to_string(primitiveEntry);
+  out << ", " << "arrayEntry=" << to_string(arrayEntry);
+  out << ", " << "mapEntry=" << to_string(mapEntry);
+  out << ", " << "structEntry=" << to_string(structEntry);
+  out << ", " << "unionEntry=" << to_string(unionEntry);
+  out << ", " << "userDefinedTypeEntry=" << to_string(userDefinedTypeEntry);
+  out << ")";
+}
+
+
+TTypeDesc::~TTypeDesc() throw() {
+}
+
+
+void TTypeDesc::__set_types(const std::vector<TTypeEntry> & val) {
+  this->types = val;
+}
+
+uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_types = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->types.clear();
+            uint32_t _size43;
+            ::apache::thrift::protocol::TType _etype46;
+            xfer += iprot->readListBegin(_etype46, _size43);
+            this->types.resize(_size43);
+            uint32_t _i47;
+            for (_i47 = 0; _i47 < _size43; ++_i47)
+            {
+              xfer += this->types[_i47].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_types = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_types)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TTypeDesc::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TTypeDesc");
+
+  xfer += oprot->writeFieldBegin("types", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->types.size()));
+    std::vector<TTypeEntry> ::const_iterator _iter48;
+    for (_iter48 = this->types.begin(); _iter48 != this->types.end(); ++_iter48)
+    {
+      xfer += (*_iter48).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TTypeDesc &a, TTypeDesc &b) {
+  using ::std::swap;
+  swap(a.types, b.types);
+}
+
+TTypeDesc::TTypeDesc(const TTypeDesc& other49) {
+  types = other49.types;
+}
+TTypeDesc& TTypeDesc::operator=(const TTypeDesc& other50) {
+  types = other50.types;
+  return *this;
+}
+void TTypeDesc::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TTypeDesc(";
+  out << "types=" << to_string(types);
+  out << ")";
+}
+
+
+TColumnDesc::~TColumnDesc() throw() {
+}
+
+
+void TColumnDesc::__set_columnName(const std::string& val) {
+  this->columnName = val;
+}
+
+void TColumnDesc::__set_typeDesc(const TTypeDesc& val) {
+  this->typeDesc = val;
+}
+
+void TColumnDesc::__set_position(const int32_t val) {
+  this->position = val;
+}
+
+void TColumnDesc::__set_comment(const std::string& val) {
+  this->comment = val;
+__isset.comment = true;
+}
+
+uint32_t TColumnDesc::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_columnName = false;
+  bool isset_typeDesc = false;
+  bool isset_position = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->columnName);
+          isset_columnName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->typeDesc.read(iprot);
+          isset_typeDesc = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->position);
+          isset_position = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->comment);
+          this->__isset.comment = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_columnName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_typeDesc)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_position)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TColumnDesc::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TColumnDesc");
+
+  xfer += oprot->writeFieldBegin("columnName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->columnName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("typeDesc", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->typeDesc.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("position", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32(this->position);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.comment) {
+    xfer += oprot->writeFieldBegin("comment", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->comment);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TColumnDesc &a, TColumnDesc &b) {
+  using ::std::swap;
+  swap(a.columnName, b.columnName);
+  swap(a.typeDesc, b.typeDesc);
+  swap(a.position, b.position);
+  swap(a.comment, b.comment);
+  swap(a.__isset, b.__isset);
+}
+
+TColumnDesc::TColumnDesc(const TColumnDesc& other51) {
+  columnName = other51.columnName;
+  typeDesc = other51.typeDesc;
+  position = other51.position;
+  comment = other51.comment;
+  __isset = other51.__isset;
+}
+TColumnDesc& TColumnDesc::operator=(const TColumnDesc& other52) {
+  columnName = other52.columnName;
+  typeDesc = other52.typeDesc;
+  position = other52.position;
+  comment = other52.comment;
+  __isset = other52.__isset;
+  return *this;
+}
+void TColumnDesc::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TColumnDesc(";
+  out << "columnName=" << to_string(columnName);
+  out << ", " << "typeDesc=" << to_string(typeDesc);
+  out << ", " << "position=" << to_string(position);
+  out << ", " << "comment="; (__isset.comment ? (out << to_string(comment)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TTableSchema::~TTableSchema() throw() {
+}
+
+
+void TTableSchema::__set_columns(const std::vector<TColumnDesc> & val) {
+  this->columns = val;
+}
+
+uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_columns = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->columns.clear();
+            uint32_t _size53;
+            ::apache::thrift::protocol::TType _etype56;
+            xfer += iprot->readListBegin(_etype56, _size53);
+            this->columns.resize(_size53);
+            uint32_t _i57;
+            for (_i57 = 0; _i57 < _size53; ++_i57)
+            {
+              xfer += this->columns[_i57].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_columns = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_columns)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TTableSchema::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TTableSchema");
+
+  xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
+    std::vector<TColumnDesc> ::const_iterator _iter58;
+    for (_iter58 = this->columns.begin(); _iter58 != this->columns.end(); ++_iter58)
+    {
+      xfer += (*_iter58).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TTableSchema &a, TTableSchema &b) {
+  using ::std::swap;
+  swap(a.columns, b.columns);
+}
+
+TTableSchema::TTableSchema(const TTableSchema& other59) {
+  columns = other59.columns;
+}
+TTableSchema& TTableSchema::operator=(const TTableSchema& other60) {
+  columns = other60.columns;
+  return *this;
+}
+void TTableSchema::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TTableSchema(";
+  out << "columns=" << to_string(columns);
+  out << ")";
+}
+
+
+TBoolValue::~TBoolValue() throw() {
+}
+
+
+void TBoolValue::__set_value(const bool val) {
+  this->value = val;
+__isset.value = true;
+}
+
+uint32_t TBoolValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TBoolValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TBoolValue");
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_BOOL, 1);
+    xfer += oprot->writeBool(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TBoolValue &a, TBoolValue &b) {
+  using ::std::swap;
+  swap(a.value, b.value);
+  swap(a.__isset, b.__isset);
+}
+
+TBoolValue::TBoolValue(const TBoolValue& other61) {
+  value = other61.value;
+  __isset = other61.__isset;
+}
+TBoolValue& TBoolValue::operator=(const TBoolValue& other62) {
+  value = other62.value;
+  __isset = other62.__isset;
+  return *this;
+}
+void TBoolValue::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TBoolValue(";
+  out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TByteValue::~TByteValue() throw() {
+}
+
+
+void TByteValue::__set_value(const int8_t val) {
+  this->value = val;
+__isset.value = true;
+}
+
+uint32_t TByteValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_BYTE) {
+          xfer += iprot->readByte(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TByteValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TByteValue");
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_BYTE, 1);
+    xfer += oprot->writeByte(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TByteValue &a, TByteValue &b) {
+  using ::std::swap;
+  swap(a.value, b.value);
+  swap(a.__isset, b.__isset);
+}
+
+TByteValue::TByteValue(const TByteValue& other63) {
+  value = other63.value;
+  __isset = other63.__isset;
+}
+TByteValue& TByteValue::operator=(const TByteValue& other64) {
+  value = other64.value;
+  __isset = other64.__isset;
+  return *this;
+}
+void TByteValue::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TByteValue(";
+  out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TI16Value::~TI16Value() throw() {
+}
+
+
+void TI16Value::__set_value(const int16_t val) {
+  this->value = val;
+__isset.value = true;
+}
+
+uint32_t TI16Value::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I16) {
+          xfer += iprot->readI16(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TI16Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TI16Value");
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I16, 1);
+    xfer += oprot->writeI16(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TI16Value &a, TI16Value &b) {
+  using ::std::swap;
+  swap(a.value, b.value);
+  swap(a.__isset, b.__isset);
+}
+
+TI16Value::TI16Value(const TI16Value& other65) {
+  value = other65.value;
+  __isset = other65.__isset;
+}
+TI16Value& TI16Value::operator=(const TI16Value& other66) {
+  value = other66.value;
+  __isset = other66.__isset;
+  return *this;
+}
+void TI16Value::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TI16Value(";
+  out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TI32Value::~TI32Value() throw() {
+}
+
+
+void TI32Value::__set_value(const int32_t val) {
+  this->value = val;
+__isset.value = true;
+}
+
+uint32_t TI32Value::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TI32Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TI32Value");
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I32, 1);
+    xfer += oprot->writeI32(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TI32Value &a, TI32Value &b) {
+  using ::std::swap;
+  swap(a.value, b.value);
+  swap(a.__isset, b.__isset);
+}
+
+TI32Value::TI32Value(const TI32Value& other67) {
+  value = other67.value;
+  __isset = other67.__isset;
+}
+TI32Value& TI32Value::operator=(const TI32Value& other68) {
+  value = other68.value;
+  __isset = other68.__isset;
+  return *this;
+}
+void TI32Value::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TI32Value(";
+  out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TI64Value::~TI64Value() throw() {
+}
+
+
+void TI64Value::__set_value(const int64_t val) {
+  this->value = val;
+__isset.value = true;
+}
+
+uint32_t TI64Value::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TI64Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TI64Value");
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 1);
+    xfer += oprot->writeI64(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TI64Value &a, TI64Value &b) {
+  using ::std::swap;
+  swap(a.value, b.value);
+  swap(a.__isset, b.__isset);
+}
+
+TI64Value::TI64Value(const TI64Value& other69) {
+  value = other69.value;
+  __isset = other69.__isset;
+}
+TI64Value& TI64Value::operator=(const TI64Value& other70) {
+  value = other70.value;
+  __isset = other70.__isset;
+  return *this;
+}
+void TI64Value::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TI64Value(";
+  out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TDoubleValue::~TDoubleValue() throw() {
+}
+
+
+void TDoubleValue::__set_value(const double val) {
+  this->value = val;
+__isset.value = true;
+}
+
+uint32_t TDoubleValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TDoubleValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TDoubleValue");
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_DOUBLE, 1);
+    xfer += oprot->writeDouble(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TDoubleValue &a, TDoubleValue &b) {
+  using ::std::swap;
+  swap(a.value, b.value);
+  swap(a.__isset, b.__isset);
+}
+
+TDoubleValue::TDoubleValue(const TDoubleValue& other71) {
+  value = other71.value;
+  __isset = other71.__isset;
+}
+TDoubleValue& TDoubleValue::operator=(const TDoubleValue& other72) {
+  value = other72.value;
+  __isset = other72.__isset;
+  return *this;
+}
+void TDoubleValue::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TDoubleValue(";
+  out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TStringValue::~TStringValue() throw() {
+}
+
+
+void TStringValue::__set_value(const std::string& val) {
+  this->value = val;
+__isset.value = true;
+}
+
+uint32_t TStringValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TStringValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TStringValue");
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeString(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TStringValue &a, TStringValue &b) {
+  using ::std::swap;
+  swap(a.value, b.value);
+  swap(a.__isset, b.__isset);
+}
+
+TStringValue::TStringValue(const TStringValue& other73) {
+  value = other73.value;
+  __isset = other73.__isset;
+}
+TStringValue& TStringValue::operator=(const TStringValue& other74) {
+  value = other74.value;
+  __isset = other74.__isset;
+  return *this;
+}
+void TStringValue::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TStringValue(";
+  out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ")";
+}
+
+
+TColumnValue::~TColumnValue() throw() {
+}
+
+
+void TColumnValue::__set_boolVal(const TBoolValue& val) {
+  this->boolVal = val;
+}
+
+void TColumnValue::__set_byteVal(const TByteValue& val) {
+  this->byteVal = val;
+}
+
+void TColumnValue::__set_i16Val(const TI16Value& val) {
+  this->i16Val = val;
+}
+
+void TColumnValue::__set_i32Val(const TI32Value& val) {
+  this->i32Val = val;
+}
+
+void TColumnValue::__set_i64Val(const TI64Value& val) {
+  this->i64Val = val;
+}
+
+void TColumnValue::__set_doubleVal(const TDoubleValue& val) {
+  this->doubleVal = val;
+}
+
+void TColumnValue::__set_stringVal(const TStringValue& val) {
+  this->stringVal = val;
+}
+
+uint32_t TColumnValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->boolVal.read(iprot);
+          this->__isset.boolVal = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->byteVal.read(iprot);
+          this->__isset.byteVal = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->i16Val.read(iprot);
+          this->__isset.i16Val = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->i32Val.read(iprot);
+          this->__isset.i32Val = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->i64Val.read(iprot);
+          this->__isset.i64Val = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->doubleVal.read(iprot);
+          this->__isset.doubleVal = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->stringVal.read(iprot);
+          this->__isset.stringVal = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TColumnValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TColumnValue");
+
+  xfer += oprot->writeFieldBegin("boolVal", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->boolVal.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("byteVal", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->byteVal.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("i16Val", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->i16Val.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("i32Val", ::apache::thrift::protocol::T_STRUCT, 4);
+  xfer += this->i32Val.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("i64Val", ::apache::thrift::protocol::T_STRUCT, 5);
+  xfer += this->i64Val.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("doubleVal", ::apache::thrift::protocol::T_STRUCT, 6);
+  xfer += this->doubleVal.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("stringVal", ::apache::thrift::protocol::T_STRUCT, 7);
+  xfer += this->stringVal.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TColumnValue &a, TColumnValue &b) {
+  using ::std::swap;
+  swap(a.boolVal, b.boolVal);
+  swap(a.byteVal, b.byteVal);
+  swap(a.i16Val, b.i16Val);
+  swap(a.i32Val, b.i32Val);
+  swap(a.i64Val, b.i64Val);
+  swap(a.doubleVal, b.doubleVal);
+  swap(a.stringVal, b.stringVal);
+  swap(a.__isset, b.__isset);
+}
+
+TColumnValue::TColumnValue(const TColumnValue& other75) {
+  boolVal = other75.boolVal;
+  byteVal = other75.byteVal;
+  i16Val = other75.i16Val;
+  i32Val = other75.i32Val;
+  i64Val = other75.i64Val;
+  doubleVal = other75.doubleVal;
+  stringVal = other75.stringVal;
+  __isset = other75.__isset;
+}
+TColumnValue& TColumnValue::operator=(const TColumnValue& other76) {
+  boolVal = other76.boolVal;
+  byteVal = other76.byteVal;
+  i16Val = other76.i16Val;
+  i32Val = other76.i32Val;
+  i64Val = other76.i64Val;
+  doubleVal = other76.doubleVal;
+  stringVal = other76.stringVal;
+  __isset = other76.__isset;
+  return *this;
+}
+void TColumnValue::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TColumnValue(";
+  out << "boolVal=" << to_string(boolVal);
+  out << ", " << "byteVal=" << to_string(byteVal);
+  out << ", " << "i16Val=" << to_string(i16Val);
+  out << ", " << "i32Val=" << to_string(i32Val);
+  out << ", " << "i64Val=" << to_string(i64Val);
+  out << ", " << "doubleVal=" << to_string(doubleVal);
+  out << ", " << "stringVal=" << to_string(stringVal);
+  out << ")";
+}
+
+
+TRow::~TRow() throw() {
+}
+
+
+void TRow::__set_colVals(const std::vector<TColumnValue> & val) {
+  this->colVals = val;
+}
+
+uint32_t TRow::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_colVals = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->colVals.clear();
+            uint32_t _size77;
+            ::apache::thrift::protocol::TType _etype80;
+            xfer += iprot->readListBegin(_etype80, _size77);
+            this->colVals.resize(_size77);
+            uint32_t _i81;
+            for (_i81 = 0; _i81 < _size77; ++_i81)
+            {
+              xfer += this->colVals[_i81].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_colVals = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_colVals)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TRow::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TRow");
+
+  xfer += oprot->writeFieldBegin("colVals", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colVals.size()));
+    std::vector<TColumnValue> ::const_iterator _iter82;
+    for (_iter82 = this->colVals.begin(); _iter82 != this->colVals.end(); ++_iter82)
+    {
+      xfer += (*_iter82).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TRow &a, TRow &b) {
+  using ::std::swap;
+  swap(a.colVals, b.colVals);
+}
+
+TRow::TRow(const TRow& other83) {
+  colVals = other83.colVals;
+}
+TRow& TRow::operator=(const TRow& other84) {
+  colVals = other84.colVals;
+  return *this;
+}
+void TRow::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TRow(";
+  out << "colVals=" << to_string(colVals);
+  out << ")";
+}
+
+
+TBoolColumn::~TBoolColumn() throw() {
+}
+
+
+void TBoolColumn::__set_values(const std::vector<bool> & val) {
+  this->values = val;
+}
+
+void TBoolColumn::__set_nulls(const std::string& val) {
+  this->nulls = val;
+}
+
+uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_values = false;
+  bool isset_nulls = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->values.clear();
+            uint32_t _size85;
+            ::apache::thrift::protocol::TType _etype88;
+            xfer += iprot->readListBegin(_etype88, _size85);
+            this->values.resize(_size85);
+            uint32_t _i89;
+            for (_i89 = 0; _i89 < _size85; ++_i89)
+            {
+              xfer += iprot->readBool(this->values[_i89]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_values = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->nulls);
+          isset_nulls = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_values)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_nulls)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TBoolColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TBoolColumn");
+
+  xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BOOL, static_cast<uint32_t>(this->values.size()));
+    std::vector<bool> ::const_iterator _iter90;
+    for (_iter90 = this->values.begin(); _iter90 != this->values.end(); ++_iter90)
+    {
+      xfer += oprot->writeBool((*_iter90));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("nulls", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->nulls);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TBoolColumn &a, TBoolColumn &b) {
+  using ::std::swap;
+  swap(a.values, b.values);
+  swap(a.nulls, b.nulls);
+}
+
+TBoolColumn::TBoolColumn(const TBoolColumn& other91) {
+  values = other91.values;
+  nulls = other91.nulls;
+}
+TBoolColumn& TBoolColumn::operator=(const TBoolColumn& other92) {
+  values = other92.values;
+  nulls = other92.nulls;
+  return *this;
+}
+void TBoolColumn::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TBoolColumn(";
+  out << "values=" << to_string(values);
+  out << ", " << "nulls=" << to_string(nulls);
+  out << ")";
+}
+
+
+TByteColumn::~TByteColumn() throw() {
+}
+
+
+void TByteColumn::__set_values(const std::vector<int8_t> & val) {
+  this->values = val;
+}
+
+void TByteColumn::__set_nulls(const std::string& val) {
+  this->nulls = val;
+}
+
+uint32_t TByteColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_values = false;
+  bool isset_nulls = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->values.clear();
+            uint32_t _size93;
+            ::apache::thrift::protocol::TType _etype96;
+            xfer += iprot->readListBegin(_etype96, _size93);
+            this->values.resize(_size93);
+            uint32_t _i97;
+            for (_i97 = 0; _i97 < _size93; ++_i97)
+            {
+              xfer += iprot->readByte(this->values[_i97]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_values = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->nulls);
+          isset_nulls = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_values)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_nulls)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TByteColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TByteColumn");
+
+  xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BYTE, static_cast<uint32_t>(this->values.size()));
+    std::vector<int8_t> ::const_iterator _iter98;
+    for (_iter98 = this->values.begin(); _iter98 != this->values.end(); ++_iter98)
+    {
+      xfer += oprot->writeByte((*_iter98));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("nulls", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->nulls);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TByteColumn &a, TByteColumn &b) {
+  using ::std::swap;
+  swap(a.values, b.values);
+  swap(a.nulls, b.nulls);
+}
+
+TByteColumn::TByteColumn(const TByteColumn& other99) {
+  values = other99.values;
+  nulls = other99.nulls;
+}
+TByteColumn& TByteColumn::operator=(const TByteColumn& other100) {
+  values = other100.values;
+  nulls = other100.nulls;
+  return *this;
+}
+void TByteColumn::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TByteColumn(";
+  out << "values=" << to_string(values);
+  out << ", " << "nulls=" << to_string(nulls);
+  out << ")";
+}
+
+
+TI16Column::~TI16Column() throw() {
+}
+
+
+void TI16Column::__set_values(const std::vector<int16_t> & val) {
+  this->values = val;
+}
+
+void TI16Column::__set_nulls(const std::string& val) {
+  this->nulls = val;
+}
+
+uint32_t TI16Column::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_values = false;
+  bool isset_nulls = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->values.clear();
+            uint32_t _size101;
+            ::apache::thrift::protocol::TType _etype104;
+            xfer += iprot->readListBegin(_etype104, _size101);
+            this->values.resize(_size101);
+            uint32_t _i105;
+            for (_i105 = 0; _i105 < _size101; ++_i105)
+            {
+              xfer += iprot->readI16(this->values[_i105]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_values = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->nulls);
+          isset_nulls = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_values)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_nulls)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TI16Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TI16Column");
+
+  xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I16, static_cast<uint32_t>(this->values.size()));
+    std::vector<int16_t> ::const_iterator _iter106;
+    for (_iter106 = this->values.begin(); _iter106 != this->values.end(); ++_iter106)
+    {
+      xfer += oprot->writeI16((*_iter106));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("nulls", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->nulls);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TI16Column &a, TI16Column &b) {
+  using ::std::swap;
+  swap(a.values, b.values);
+  swap(a.nulls, b.nulls);
+}
+
+TI16Column::TI16Column(const TI16Column& other107) {
+  values = other107.values;
+  nulls = other107.nulls;
+}
+TI16Column& TI16Column::operator=(const TI16Column& other108) {
+  values = other108.values;
+  nulls = other108.nulls;
+  return *this;
+}
+void TI16Column::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TI16Column(";
+  out << "values=" << to_string(values);
+  out << ", " << "nulls=" << to_string(nulls);
+  out << ")";
+}
+
+
+TI32Column::~TI32Column() throw() {
+}
+
+
+void TI32Column::__set_values(const std::vector<int32_t> & val) {
+  this->values = val;
+}
+
+void TI32Column::__set_nulls(const std::string& val) {
+  this->nulls = val;
+}
+
+uint32_t TI32Column::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_values = false;
+  bool isset_nulls = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->values.clear();
+            uint32_t _size109;
+            ::apache::thrift::protocol::TType _etype112;
+            xfer += iprot->readListBegin(_etype112, _size109);
+            this->values.resize(_size109);
+            uint32_t _i113;
+            for (_i113 = 0; _i113 < _size109; ++_i113)
+            {
+              xfer += iprot->readI32(this->values[_i113]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_values = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->nulls);
+          isset_nulls = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_values)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_nulls)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TI32Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("TI32Column");
+
+  xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->values.size()));
+    std::vector<int32_t> ::const_iterator _iter114;
+    for (_iter114 = this->values.begin(); _iter114 != this->values.end(); ++_iter114)
+    {
+      xfer += oprot->writeI32((*_iter114));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("nulls", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->nulls);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TI32Column &a, TI32Column &b) {
+  using ::std::swap;
+  swap(a.values, b.values);
+  swap(a.nulls, b.nulls);
+}
+
+TI32Column::TI32Column(const TI32Column& other115) {
+  values = other115.values;
+  nulls = other115.nulls;
+}
+TI32Column& TI32Column::operator=(const TI32Column& other116) {
+  values = other116.values;
+  nulls = other116.nulls;
+  return *this;
+}
+void TI32Column::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "TI32Column(";
+  out << "values=" << to_string(values);
+  out << ", " << "nulls=" << to_string(nulls);
+  out << ")";
+}
+
+
+TI64Column::~TI64Column() throw() {
+}
+
+
+void TI64Column::__set_values(const std::vector<int64_t> & val) {
+  this->values = val;
+}
+
+void TI64Column::__set_nulls(const std::string& val) {
+  this->nulls = val;
+}
+
+uint32_t TI64Column::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  u

<TRUNCATED>