You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by ha...@apache.org on 2013/03/12 18:45:12 UTC
svn commit: r1455646 [4/25] - in /hive/trunk/service/src/gen/thrift:
gen-cpp/ gen-javabean/org/apache/hive/ gen-javabean/org/apache/hive/service/
gen-javabean/org/apache/hive/service/cli/
gen-javabean/org/apache/hive/service/cli/thrift/ gen-php/ gen-py...
Added: hive/trunk/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp?rev=1455646&view=auto
==============================================================================
--- hive/trunk/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp (added)
+++ hive/trunk/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp Tue Mar 12 17:45:10 2013
@@ -0,0 +1,5400 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "TCLIService_types.h"
+
+#include <algorithm>
+
+namespace apache { namespace hive { namespace service { namespace cli { namespace thrift {
+
+int _kTProtocolVersionValues[] = {
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V1
+};
+const char* _kTProtocolVersionNames[] = {
+ "HIVE_CLI_SERVICE_PROTOCOL_V1"
+};
+const std::map<int, const char*> _TProtocolVersion_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(1, _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
+};
+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"
+};
+const std::map<int, const char*> _TTypeId_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(16, _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
+};
+const char* _kTOperationStateNames[] = {
+ "INITIALIZED_STATE",
+ "RUNNING_STATE",
+ "FINISHED_STATE",
+ "CANCELED_STATE",
+ "CLOSED_STATE",
+ "ERROR_STATE",
+ "UKNOWN_STATE"
+};
+const std::map<int, const char*> _TOperationState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(7, _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));
+
+const char* TPrimitiveTypeEntry::ascii_fingerprint = "8BBB3D0C3B370CB38F2D1340BB79F0AA";
+const uint8_t TPrimitiveTypeEntry::binary_fingerprint[16] = {0x8B,0xBB,0x3D,0x0C,0x3B,0x37,0x0C,0xB3,0x8F,0x2D,0x13,0x40,0xBB,0x79,0xF0,0xAA};
+
+uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* 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 ecast0;
+ xfer += iprot->readI32(ecast0);
+ this->type = (TTypeId::type)ecast0;
+ isset_type = 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;
+ xfer += oprot->writeStructBegin("TPrimitiveTypeEntry");
+
+ xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->type);
+ 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);
+}
+
+const char* TArrayTypeEntry::ascii_fingerprint = "E86CACEB22240450EDCBEFC3A83970E4";
+const uint8_t TArrayTypeEntry::binary_fingerprint[16] = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4};
+
+uint32_t TArrayTypeEntry::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TMapTypeEntry::ascii_fingerprint = "989D1F1AE8D148D5E2119FFEC4BBBEE3";
+const uint8_t TMapTypeEntry::binary_fingerprint[16] = {0x98,0x9D,0x1F,0x1A,0xE8,0xD1,0x48,0xD5,0xE2,0x11,0x9F,0xFE,0xC4,0xBB,0xBE,0xE3};
+
+uint32_t TMapTypeEntry::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TStructTypeEntry::ascii_fingerprint = "91F548CA159B4AB4291F5741AC161402";
+const uint8_t TStructTypeEntry::binary_fingerprint[16] = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02};
+
+uint32_t TStructTypeEntry::read(::apache::thrift::protocol::TProtocol* 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 _size1;
+ ::apache::thrift::protocol::TType _ktype2;
+ ::apache::thrift::protocol::TType _vtype3;
+ xfer += iprot->readMapBegin(_ktype2, _vtype3, _size1);
+ uint32_t _i5;
+ for (_i5 = 0; _i5 < _size1; ++_i5)
+ {
+ std::string _key6;
+ xfer += iprot->readString(_key6);
+ TTypeEntryPtr& _val7 = this->nameToTypePtr[_key6];
+ xfer += iprot->readI32(_val7);
+ }
+ 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;
+ 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 _iter8;
+ for (_iter8 = this->nameToTypePtr.begin(); _iter8 != this->nameToTypePtr.end(); ++_iter8)
+ {
+ xfer += oprot->writeString(_iter8->first);
+ xfer += oprot->writeI32(_iter8->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);
+}
+
+const char* TUnionTypeEntry::ascii_fingerprint = "91F548CA159B4AB4291F5741AC161402";
+const uint8_t TUnionTypeEntry::binary_fingerprint[16] = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02};
+
+uint32_t TUnionTypeEntry::read(::apache::thrift::protocol::TProtocol* 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 _size9;
+ ::apache::thrift::protocol::TType _ktype10;
+ ::apache::thrift::protocol::TType _vtype11;
+ xfer += iprot->readMapBegin(_ktype10, _vtype11, _size9);
+ uint32_t _i13;
+ for (_i13 = 0; _i13 < _size9; ++_i13)
+ {
+ std::string _key14;
+ xfer += iprot->readString(_key14);
+ TTypeEntryPtr& _val15 = this->nameToTypePtr[_key14];
+ xfer += iprot->readI32(_val15);
+ }
+ 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;
+ 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 _iter16;
+ for (_iter16 = this->nameToTypePtr.begin(); _iter16 != this->nameToTypePtr.end(); ++_iter16)
+ {
+ xfer += oprot->writeString(_iter16->first);
+ xfer += oprot->writeI32(_iter16->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);
+}
+
+const char* TUserDefinedTypeEntry::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t TUserDefinedTypeEntry::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t TUserDefinedTypeEntry::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TTypeEntry::ascii_fingerprint = "0C3ACE4054603E2D37B8BFEBA79F4159";
+const uint8_t TTypeEntry::binary_fingerprint[16] = {0x0C,0x3A,0xCE,0x40,0x54,0x60,0x3E,0x2D,0x37,0xB8,0xBF,0xEB,0xA7,0x9F,0x41,0x59};
+
+uint32_t TTypeEntry::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TTypeDesc::ascii_fingerprint = "60CA5B8BACFCD38D1D3EC1F0E3F1C36A";
+const uint8_t TTypeDesc::binary_fingerprint[16] = {0x60,0xCA,0x5B,0x8B,0xAC,0xFC,0xD3,0x8D,0x1D,0x3E,0xC1,0xF0,0xE3,0xF1,0xC3,0x6A};
+
+uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* 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 _size17;
+ ::apache::thrift::protocol::TType _etype20;
+ xfer += iprot->readListBegin(_etype20, _size17);
+ this->types.resize(_size17);
+ uint32_t _i21;
+ for (_i21 = 0; _i21 < _size17; ++_i21)
+ {
+ xfer += this->types[_i21].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;
+ 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 _iter22;
+ for (_iter22 = this->types.begin(); _iter22 != this->types.end(); ++_iter22)
+ {
+ xfer += (*_iter22).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);
+}
+
+const char* TColumnDesc::ascii_fingerprint = "0DF9A37B81B1EE73D35A0AC01F33A48D";
+const uint8_t TColumnDesc::binary_fingerprint[16] = {0x0D,0xF9,0xA3,0x7B,0x81,0xB1,0xEE,0x73,0xD3,0x5A,0x0A,0xC0,0x1F,0x33,0xA4,0x8D};
+
+uint32_t TColumnDesc::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TTableSchema::ascii_fingerprint = "E67E789F1EF836E4B9FC922C788AFDC8";
+const uint8_t TTableSchema::binary_fingerprint[16] = {0xE6,0x7E,0x78,0x9F,0x1E,0xF8,0x36,0xE4,0xB9,0xFC,0x92,0x2C,0x78,0x8A,0xFD,0xC8};
+
+uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* 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 _size23;
+ ::apache::thrift::protocol::TType _etype26;
+ xfer += iprot->readListBegin(_etype26, _size23);
+ this->columns.resize(_size23);
+ uint32_t _i27;
+ for (_i27 = 0; _i27 < _size23; ++_i27)
+ {
+ xfer += this->columns[_i27].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;
+ 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 _iter28;
+ for (_iter28 = this->columns.begin(); _iter28 != this->columns.end(); ++_iter28)
+ {
+ xfer += (*_iter28).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);
+}
+
+const char* TBoolValue::ascii_fingerprint = "BF054652DEF86253C2BEE7D947F167DD";
+const uint8_t TBoolValue::binary_fingerprint[16] = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD};
+
+uint32_t TBoolValue::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TByteValue::ascii_fingerprint = "9C15298ACB5D04AEA9B52D5DDE6F9208";
+const uint8_t TByteValue::binary_fingerprint[16] = {0x9C,0x15,0x29,0x8A,0xCB,0x5D,0x04,0xAE,0xA9,0xB5,0x2D,0x5D,0xDE,0x6F,0x92,0x08};
+
+uint32_t TByteValue::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TI16Value::ascii_fingerprint = "5DAC9C51C7E1106BF936FC71860BE9D5";
+const uint8_t TI16Value::binary_fingerprint[16] = {0x5D,0xAC,0x9C,0x51,0xC7,0xE1,0x10,0x6B,0xF9,0x36,0xFC,0x71,0x86,0x0B,0xE9,0xD5};
+
+uint32_t TI16Value::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TI32Value::ascii_fingerprint = "E7A96B151330359E84C0A3AC91BCBACD";
+const uint8_t TI32Value::binary_fingerprint[16] = {0xE7,0xA9,0x6B,0x15,0x13,0x30,0x35,0x9E,0x84,0xC0,0xA3,0xAC,0x91,0xBC,0xBA,0xCD};
+
+uint32_t TI32Value::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TI64Value::ascii_fingerprint = "148F3AAAC1D9859963D5E800D187BF26";
+const uint8_t TI64Value::binary_fingerprint[16] = {0x14,0x8F,0x3A,0xAA,0xC1,0xD9,0x85,0x99,0x63,0xD5,0xE8,0x00,0xD1,0x87,0xBF,0x26};
+
+uint32_t TI64Value::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TDoubleValue::ascii_fingerprint = "3586E570A474C4A8603B4FF74903B3A6";
+const uint8_t TDoubleValue::binary_fingerprint[16] = {0x35,0x86,0xE5,0x70,0xA4,0x74,0xC4,0xA8,0x60,0x3B,0x4F,0xF7,0x49,0x03,0xB3,0xA6};
+
+uint32_t TDoubleValue::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TStringValue::ascii_fingerprint = "66E694018C17E5B65A59AE8F55CCA3CD";
+const uint8_t TStringValue::binary_fingerprint[16] = {0x66,0xE6,0x94,0x01,0x8C,0x17,0xE5,0xB6,0x5A,0x59,0xAE,0x8F,0x55,0xCC,0xA3,0xCD};
+
+uint32_t TStringValue::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TColumn::ascii_fingerprint = "B39B4E4E565DB31DC891D62FDC3208DC";
+const uint8_t TColumn::binary_fingerprint[16] = {0xB3,0x9B,0x4E,0x4E,0x56,0x5D,0xB3,0x1D,0xC8,0x91,0xD6,0x2F,0xDC,0x32,0x08,0xDC};
+
+uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* 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_LIST) {
+ {
+ this->boolColumn.clear();
+ uint32_t _size29;
+ ::apache::thrift::protocol::TType _etype32;
+ xfer += iprot->readListBegin(_etype32, _size29);
+ this->boolColumn.resize(_size29);
+ uint32_t _i33;
+ for (_i33 = 0; _i33 < _size29; ++_i33)
+ {
+ xfer += this->boolColumn[_i33].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.boolColumn = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->byteColumn.clear();
+ uint32_t _size34;
+ ::apache::thrift::protocol::TType _etype37;
+ xfer += iprot->readListBegin(_etype37, _size34);
+ this->byteColumn.resize(_size34);
+ uint32_t _i38;
+ for (_i38 = 0; _i38 < _size34; ++_i38)
+ {
+ xfer += this->byteColumn[_i38].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.byteColumn = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->i16Column.clear();
+ uint32_t _size39;
+ ::apache::thrift::protocol::TType _etype42;
+ xfer += iprot->readListBegin(_etype42, _size39);
+ this->i16Column.resize(_size39);
+ uint32_t _i43;
+ for (_i43 = 0; _i43 < _size39; ++_i43)
+ {
+ xfer += this->i16Column[_i43].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.i16Column = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->i32Column.clear();
+ uint32_t _size44;
+ ::apache::thrift::protocol::TType _etype47;
+ xfer += iprot->readListBegin(_etype47, _size44);
+ this->i32Column.resize(_size44);
+ uint32_t _i48;
+ for (_i48 = 0; _i48 < _size44; ++_i48)
+ {
+ xfer += this->i32Column[_i48].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.i32Column = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->i64Column.clear();
+ uint32_t _size49;
+ ::apache::thrift::protocol::TType _etype52;
+ xfer += iprot->readListBegin(_etype52, _size49);
+ this->i64Column.resize(_size49);
+ uint32_t _i53;
+ for (_i53 = 0; _i53 < _size49; ++_i53)
+ {
+ xfer += this->i64Column[_i53].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.i64Column = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->doubleColumn.clear();
+ uint32_t _size54;
+ ::apache::thrift::protocol::TType _etype57;
+ xfer += iprot->readListBegin(_etype57, _size54);
+ this->doubleColumn.resize(_size54);
+ uint32_t _i58;
+ for (_i58 = 0; _i58 < _size54; ++_i58)
+ {
+ xfer += this->doubleColumn[_i58].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.doubleColumn = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->stringColumn.clear();
+ uint32_t _size59;
+ ::apache::thrift::protocol::TType _etype62;
+ xfer += iprot->readListBegin(_etype62, _size59);
+ this->stringColumn.resize(_size59);
+ uint32_t _i63;
+ for (_i63 = 0; _i63 < _size59; ++_i63)
+ {
+ xfer += this->stringColumn[_i63].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.stringColumn = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TColumn");
+
+ xfer += oprot->writeFieldBegin("boolColumn", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->boolColumn.size()));
+ std::vector<TBoolValue> ::const_iterator _iter64;
+ for (_iter64 = this->boolColumn.begin(); _iter64 != this->boolColumn.end(); ++_iter64)
+ {
+ xfer += (*_iter64).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("byteColumn", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->byteColumn.size()));
+ std::vector<TByteValue> ::const_iterator _iter65;
+ for (_iter65 = this->byteColumn.begin(); _iter65 != this->byteColumn.end(); ++_iter65)
+ {
+ xfer += (*_iter65).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("i16Column", ::apache::thrift::protocol::T_LIST, 3);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->i16Column.size()));
+ std::vector<TI16Value> ::const_iterator _iter66;
+ for (_iter66 = this->i16Column.begin(); _iter66 != this->i16Column.end(); ++_iter66)
+ {
+ xfer += (*_iter66).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("i32Column", ::apache::thrift::protocol::T_LIST, 4);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->i32Column.size()));
+ std::vector<TI32Value> ::const_iterator _iter67;
+ for (_iter67 = this->i32Column.begin(); _iter67 != this->i32Column.end(); ++_iter67)
+ {
+ xfer += (*_iter67).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("i64Column", ::apache::thrift::protocol::T_LIST, 5);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->i64Column.size()));
+ std::vector<TI64Value> ::const_iterator _iter68;
+ for (_iter68 = this->i64Column.begin(); _iter68 != this->i64Column.end(); ++_iter68)
+ {
+ xfer += (*_iter68).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("doubleColumn", ::apache::thrift::protocol::T_LIST, 6);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->doubleColumn.size()));
+ std::vector<TDoubleValue> ::const_iterator _iter69;
+ for (_iter69 = this->doubleColumn.begin(); _iter69 != this->doubleColumn.end(); ++_iter69)
+ {
+ xfer += (*_iter69).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("stringColumn", ::apache::thrift::protocol::T_LIST, 7);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->stringColumn.size()));
+ std::vector<TStringValue> ::const_iterator _iter70;
+ for (_iter70 = this->stringColumn.begin(); _iter70 != this->stringColumn.end(); ++_iter70)
+ {
+ xfer += (*_iter70).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TColumn &a, TColumn &b) {
+ using ::std::swap;
+ swap(a.boolColumn, b.boolColumn);
+ swap(a.byteColumn, b.byteColumn);
+ swap(a.i16Column, b.i16Column);
+ swap(a.i32Column, b.i32Column);
+ swap(a.i64Column, b.i64Column);
+ swap(a.doubleColumn, b.doubleColumn);
+ swap(a.stringColumn, b.stringColumn);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TColumnValue::ascii_fingerprint = "C2DDD988447EA7999A8285AA38AAE9AD";
+const uint8_t TColumnValue::binary_fingerprint[16] = {0xC2,0xDD,0xD9,0x88,0x44,0x7E,0xA7,0x99,0x9A,0x82,0x85,0xAA,0x38,0xAA,0xE9,0xAD};
+
+uint32_t TColumnValue::read(::apache::thrift::protocol::TProtocol* 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;
+ 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);
+}
+
+const char* TRow::ascii_fingerprint = "E73FD1FCA0CA58A669FC3E02FB68D534";
+const uint8_t TRow::binary_fingerprint[16] = {0xE7,0x3F,0xD1,0xFC,0xA0,0xCA,0x58,0xA6,0x69,0xFC,0x3E,0x02,0xFB,0x68,0xD5,0x34};
+
+uint32_t TRow::read(::apache::thrift::protocol::TProtocol* 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 _size71;
+ ::apache::thrift::protocol::TType _etype74;
+ xfer += iprot->readListBegin(_etype74, _size71);
+ this->colVals.resize(_size71);
+ uint32_t _i75;
+ for (_i75 = 0; _i75 < _size71; ++_i75)
+ {
+ xfer += this->colVals[_i75].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;
+ 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 _iter76;
+ for (_iter76 = this->colVals.begin(); _iter76 != this->colVals.end(); ++_iter76)
+ {
+ xfer += (*_iter76).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);
+}
+
+const char* TRowSet::ascii_fingerprint = "698727A24268879440EE0DAFE68FC1C5";
+const uint8_t TRowSet::binary_fingerprint[16] = {0x69,0x87,0x27,0xA2,0x42,0x68,0x87,0x94,0x40,0xEE,0x0D,0xAF,0xE6,0x8F,0xC1,0xC5};
+
+uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* 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_startRowOffset = false;
+ bool isset_rows = 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_I64) {
+ xfer += iprot->readI64(this->startRowOffset);
+ isset_startRowOffset = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->rows.clear();
+ uint32_t _size77;
+ ::apache::thrift::protocol::TType _etype80;
+ xfer += iprot->readListBegin(_etype80, _size77);
+ this->rows.resize(_size77);
+ uint32_t _i81;
+ for (_i81 = 0; _i81 < _size77; ++_i81)
+ {
+ xfer += this->rows[_i81].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_rows = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->columns.clear();
+ uint32_t _size82;
+ ::apache::thrift::protocol::TType _etype85;
+ xfer += iprot->readListBegin(_etype85, _size82);
+ this->columns.resize(_size82);
+ uint32_t _i86;
+ for (_i86 = 0; _i86 < _size82; ++_i86)
+ {
+ xfer += this->columns[_i86].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.columns = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_startRowOffset)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_rows)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TRowSet");
+
+ xfer += oprot->writeFieldBegin("startRowOffset", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->startRowOffset);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rows.size()));
+ std::vector<TRow> ::const_iterator _iter87;
+ for (_iter87 = this->rows.begin(); _iter87 != this->rows.end(); ++_iter87)
+ {
+ xfer += (*_iter87).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.columns) {
+ xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
+ std::vector<TColumn> ::const_iterator _iter88;
+ for (_iter88 = this->columns.begin(); _iter88 != this->columns.end(); ++_iter88)
+ {
+ xfer += (*_iter88).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TRowSet &a, TRowSet &b) {
+ using ::std::swap;
+ swap(a.startRowOffset, b.startRowOffset);
+ swap(a.rows, b.rows);
+ swap(a.columns, b.columns);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TStatus::ascii_fingerprint = "D5DEF49634A59C615C1B3A6F7D0DADB5";
+const uint8_t TStatus::binary_fingerprint[16] = {0xD5,0xDE,0xF4,0x96,0x34,0xA5,0x9C,0x61,0x5C,0x1B,0x3A,0x6F,0x7D,0x0D,0xAD,0xB5};
+
+uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* 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_statusCode = 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 ecast89;
+ xfer += iprot->readI32(ecast89);
+ this->statusCode = (TStatusCode::type)ecast89;
+ isset_statusCode = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->infoMessages.clear();
+ uint32_t _size90;
+ ::apache::thrift::protocol::TType _etype93;
+ xfer += iprot->readListBegin(_etype93, _size90);
+ this->infoMessages.resize(_size90);
+ uint32_t _i94;
+ for (_i94 = 0; _i94 < _size90; ++_i94)
+ {
+ xfer += iprot->readString(this->infoMessages[_i94]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.infoMessages = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->sqlState);
+ this->__isset.sqlState = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->errorCode);
+ this->__isset.errorCode = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->errorMessage);
+ this->__isset.errorMessage = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_statusCode)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TStatus");
+
+ xfer += oprot->writeFieldBegin("statusCode", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->statusCode);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.infoMessages) {
+ xfer += oprot->writeFieldBegin("infoMessages", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->infoMessages.size()));
+ std::vector<std::string> ::const_iterator _iter95;
+ for (_iter95 = this->infoMessages.begin(); _iter95 != this->infoMessages.end(); ++_iter95)
+ {
+ xfer += oprot->writeString((*_iter95));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.sqlState) {
+ xfer += oprot->writeFieldBegin("sqlState", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->sqlState);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.errorCode) {
+ xfer += oprot->writeFieldBegin("errorCode", ::apache::thrift::protocol::T_I32, 4);
+ xfer += oprot->writeI32(this->errorCode);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.errorMessage) {
+ xfer += oprot->writeFieldBegin("errorMessage", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->errorMessage);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TStatus &a, TStatus &b) {
+ using ::std::swap;
+ swap(a.statusCode, b.statusCode);
+ swap(a.infoMessages, b.infoMessages);
+ swap(a.sqlState, b.sqlState);
+ swap(a.errorCode, b.errorCode);
+ swap(a.errorMessage, b.errorMessage);
+ swap(a.__isset, b.__isset);
+}
+
+const char* THandleIdentifier::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972";
+const uint8_t THandleIdentifier::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
+uint32_t THandleIdentifier::read(::apache::thrift::protocol::TProtocol* 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_guid = false;
+ bool isset_secret = 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->readBinary(this->guid);
+ isset_guid = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readBinary(this->secret);
+ isset_secret = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_guid)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_secret)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t THandleIdentifier::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("THandleIdentifier");
+
+ xfer += oprot->writeFieldBegin("guid", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeBinary(this->guid);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("secret", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeBinary(this->secret);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(THandleIdentifier &a, THandleIdentifier &b) {
+ using ::std::swap;
+ swap(a.guid, b.guid);
+ swap(a.secret, b.secret);
+}
+
+const char* TSessionHandle::ascii_fingerprint = "A756D3DBE614FB13F70BF7F7B6EB3D73";
+const uint8_t TSessionHandle::binary_fingerprint[16] = {0xA7,0x56,0xD3,0xDB,0xE6,0x14,0xFB,0x13,0xF7,0x0B,0xF7,0xF7,0xB6,0xEB,0x3D,0x73};
+
+uint32_t TSessionHandle::read(::apache::thrift::protocol::TProtocol* 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_sessionId = 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_STRUCT) {
+ xfer += this->sessionId.read(iprot);
+ isset_sessionId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_sessionId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TSessionHandle::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TSessionHandle");
+
+ xfer += oprot->writeFieldBegin("sessionId", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionId.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TSessionHandle &a, TSessionHandle &b) {
+ using ::std::swap;
+ swap(a.sessionId, b.sessionId);
+}
+
+const char* TOperationHandle::ascii_fingerprint = "29FD80F4F96804A30FCC59C23D2E5349";
+const uint8_t TOperationHandle::binary_fingerprint[16] = {0x29,0xFD,0x80,0xF4,0xF9,0x68,0x04,0xA3,0x0F,0xCC,0x59,0xC2,0x3D,0x2E,0x53,0x49};
+
+uint32_t TOperationHandle::read(::apache::thrift::protocol::TProtocol* 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_operationId = false;
+ bool isset_operationType = false;
+ bool isset_hasResultSet = 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_STRUCT) {
+ xfer += this->operationId.read(iprot);
+ isset_operationId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast96;
+ xfer += iprot->readI32(ecast96);
+ this->operationType = (TOperationType::type)ecast96;
+ isset_operationType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->hasResultSet);
+ isset_hasResultSet = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+ xfer += iprot->readDouble(this->modifiedRowCount);
+ this->__isset.modifiedRowCount = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_operationId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_operationType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_hasResultSet)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TOperationHandle::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TOperationHandle");
+
+ xfer += oprot->writeFieldBegin("operationId", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->operationId.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("operationType", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((int32_t)this->operationType);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("hasResultSet", ::apache::thrift::protocol::T_BOOL, 3);
+ xfer += oprot->writeBool(this->hasResultSet);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.modifiedRowCount) {
+ xfer += oprot->writeFieldBegin("modifiedRowCount", ::apache::thrift::protocol::T_DOUBLE, 4);
+ xfer += oprot->writeDouble(this->modifiedRowCount);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TOperationHandle &a, TOperationHandle &b) {
+ using ::std::swap;
+ swap(a.operationId, b.operationId);
+ swap(a.operationType, b.operationType);
+ swap(a.hasResultSet, b.hasResultSet);
+ swap(a.modifiedRowCount, b.modifiedRowCount);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TOpenSessionReq::ascii_fingerprint = "C8FD0F306A16C16BDA7B57F58BFAE5B2";
+const uint8_t TOpenSessionReq::binary_fingerprint[16] = {0xC8,0xFD,0x0F,0x30,0x6A,0x16,0xC1,0x6B,0xDA,0x7B,0x57,0xF5,0x8B,0xFA,0xE5,0xB2};
+
+uint32_t TOpenSessionReq::read(::apache::thrift::protocol::TProtocol* 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_client_protocol = 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 ecast97;
+ xfer += iprot->readI32(ecast97);
+ this->client_protocol = (TProtocolVersion::type)ecast97;
+ isset_client_protocol = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->username);
+ this->__isset.username = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->password);
+ this->__isset.password = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->configuration.clear();
+ uint32_t _size98;
+ ::apache::thrift::protocol::TType _ktype99;
+ ::apache::thrift::protocol::TType _vtype100;
+ xfer += iprot->readMapBegin(_ktype99, _vtype100, _size98);
+ uint32_t _i102;
+ for (_i102 = 0; _i102 < _size98; ++_i102)
+ {
+ std::string _key103;
+ xfer += iprot->readString(_key103);
+ std::string& _val104 = this->configuration[_key103];
+ xfer += iprot->readString(_val104);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.configuration = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_client_protocol)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TOpenSessionReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TOpenSessionReq");
+
+ xfer += oprot->writeFieldBegin("client_protocol", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->client_protocol);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.username) {
+ xfer += oprot->writeFieldBegin("username", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->username);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.password) {
+ xfer += oprot->writeFieldBegin("password", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->password);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.configuration) {
+ xfer += oprot->writeFieldBegin("configuration", ::apache::thrift::protocol::T_MAP, 4);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->configuration.size()));
+ std::map<std::string, std::string> ::const_iterator _iter105;
+ for (_iter105 = this->configuration.begin(); _iter105 != this->configuration.end(); ++_iter105)
+ {
+ xfer += oprot->writeString(_iter105->first);
+ xfer += oprot->writeString(_iter105->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TOpenSessionReq &a, TOpenSessionReq &b) {
+ using ::std::swap;
+ swap(a.client_protocol, b.client_protocol);
+ swap(a.username, b.username);
+ swap(a.password, b.password);
+ swap(a.configuration, b.configuration);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TOpenSessionResp::ascii_fingerprint = "CFE7D7F4E9EC671F2518ED74FEE9F163";
+const uint8_t TOpenSessionResp::binary_fingerprint[16] = {0xCF,0xE7,0xD7,0xF4,0xE9,0xEC,0x67,0x1F,0x25,0x18,0xED,0x74,0xFE,0xE9,0xF1,0x63};
+
+uint32_t TOpenSessionResp::read(::apache::thrift::protocol::TProtocol* 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_status = false;
+ bool isset_serverProtocolVersion = 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_STRUCT) {
+ xfer += this->status.read(iprot);
+ isset_status = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast106;
+ xfer += iprot->readI32(ecast106);
+ this->serverProtocolVersion = (TProtocolVersion::type)ecast106;
+ isset_serverProtocolVersion = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sessionHandle.read(iprot);
+ this->__isset.sessionHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->configuration.clear();
+ uint32_t _size107;
+ ::apache::thrift::protocol::TType _ktype108;
+ ::apache::thrift::protocol::TType _vtype109;
+ xfer += iprot->readMapBegin(_ktype108, _vtype109, _size107);
+ uint32_t _i111;
+ for (_i111 = 0; _i111 < _size107; ++_i111)
+ {
+ std::string _key112;
+ xfer += iprot->readString(_key112);
+ std::string& _val113 = this->configuration[_key112];
+ xfer += iprot->readString(_val113);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.configuration = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_status)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_serverProtocolVersion)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TOpenSessionResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TOpenSessionResp");
+
+ xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->status.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("serverProtocolVersion", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((int32_t)this->serverProtocolVersion);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.sessionHandle) {
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.configuration) {
+ xfer += oprot->writeFieldBegin("configuration", ::apache::thrift::protocol::T_MAP, 4);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->configuration.size()));
+ std::map<std::string, std::string> ::const_iterator _iter114;
+ for (_iter114 = this->configuration.begin(); _iter114 != this->configuration.end(); ++_iter114)
+ {
+ xfer += oprot->writeString(_iter114->first);
+ xfer += oprot->writeString(_iter114->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TOpenSessionResp &a, TOpenSessionResp &b) {
+ using ::std::swap;
+ swap(a.status, b.status);
+ swap(a.serverProtocolVersion, b.serverProtocolVersion);
+ swap(a.sessionHandle, b.sessionHandle);
+ swap(a.configuration, b.configuration);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TCloseSessionReq::ascii_fingerprint = "82377107F8BD0526960537D5A112E6EF";
+const uint8_t TCloseSessionReq::binary_fingerprint[16] = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF};
+
+uint32_t TCloseSessionReq::read(::apache::thrift::protocol::TProtocol* 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_sessionHandle = 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_STRUCT) {
+ xfer += this->sessionHandle.read(iprot);
+ isset_sessionHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_sessionHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TCloseSessionReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCloseSessionReq");
+
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
[... 2507 lines stripped ...]