diff --git jdbc/src/java/org/apache/hive/jdbc/HiveBaseResultSet.java jdbc/src/java/org/apache/hive/jdbc/HiveBaseResultSet.java index f47df43..2daf46e 100644 --- jdbc/src/java/org/apache/hive/jdbc/HiveBaseResultSet.java +++ jdbc/src/java/org/apache/hive/jdbc/HiveBaseResultSet.java @@ -64,6 +64,7 @@ protected TRow row; protected List columnNames; protected List columnTypes; + protected List columnAttributes; private TableSchema schema; @@ -351,7 +352,7 @@ public long getLong(String columnName) throws SQLException { } public ResultSetMetaData getMetaData() throws SQLException { - return new HiveResultSetMetaData(columnNames, columnTypes); + return new HiveResultSetMetaData(columnNames, columnTypes, columnAttributes); } public Reader getNCharacterStream(int arg0) throws SQLException { @@ -509,6 +510,8 @@ private Object getColumnValue(int columnIndex) throws SQLException { return getDoubleValue(tColumnValue.getDoubleVal()); case STRING_TYPE: return getStringValue(tColumnValue.getStringVal()); + case VARCHAR_TYPE: + return getStringValue(tColumnValue.getStringVal()); case BINARY_TYPE: return getBinaryValue(tColumnValue.getStringVal()); case DATE_TYPE: diff --git jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java index 7b286fe..5af23ac 100644 --- jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java +++ jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java @@ -101,10 +101,10 @@ public HiveConnection(String uri, Properties info) throws SQLException { openTransport(uri, connParams.getHost(), connParams.getPort(), connParams.getSessionVars()); } - // add supported protocols: V1 and V2 supported + // add supported protocols supportedProtocols.add(TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V1); - supportedProtocols.add(TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V2); + supportedProtocols.add(TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V3); // open client session openSession(uri); diff --git jdbc/src/java/org/apache/hive/jdbc/HiveQueryResultSet.java jdbc/src/java/org/apache/hive/jdbc/HiveQueryResultSet.java index 61985d1..609636d 100644 --- jdbc/src/java/org/apache/hive/jdbc/HiveQueryResultSet.java +++ jdbc/src/java/org/apache/hive/jdbc/HiveQueryResultSet.java @@ -29,7 +29,9 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hive.service.cli.TableSchema; +import org.apache.hive.service.cli.TypeQualifiers; import org.apache.hive.service.cli.thrift.TCLIService; +import org.apache.hive.service.cli.thrift.TCLIServiceConstants; import org.apache.hive.service.cli.thrift.TColumnDesc; import org.apache.hive.service.cli.thrift.TFetchOrientation; import org.apache.hive.service.cli.thrift.TFetchResultsReq; @@ -37,9 +39,12 @@ import org.apache.hive.service.cli.thrift.TGetResultSetMetadataReq; import org.apache.hive.service.cli.thrift.TGetResultSetMetadataResp; import org.apache.hive.service.cli.thrift.TOperationHandle; +import org.apache.hive.service.cli.thrift.TPrimitiveTypeEntry; import org.apache.hive.service.cli.thrift.TRow; import org.apache.hive.service.cli.thrift.TSessionHandle; import org.apache.hive.service.cli.thrift.TTableSchema; +import org.apache.hive.service.cli.thrift.TTypeQualifierValue; +import org.apache.hive.service.cli.thrift.TTypeQualifiers; /** * HiveQueryResultSet. @@ -76,6 +81,7 @@ private boolean retrieveSchema = true; private List colNames; private List colTypes; + private List colAttributes; private int fetchSize = 50; private boolean emptyResultSet = false; @@ -100,10 +106,23 @@ public Builder setMaxRows(int maxRows) { } public Builder setSchema(List colNames, List colTypes) { + // no column attributes provided - create list of null attributes. + List colAttributes = + new ArrayList(); + for (int idx = 0; idx < colTypes.size(); ++idx) { + colAttributes.add(null); + } + return setSchema(colNames, colTypes, colAttributes); + } + + public Builder setSchema(List colNames, List colTypes, + List colAttributes) { this.colNames = new ArrayList(); this.colNames.addAll(colNames); this.colTypes = new ArrayList(); this.colTypes.addAll(colTypes); + this.colAttributes = new ArrayList(); + this.colAttributes.addAll(colAttributes); this.retrieveSchema = false; return this; } @@ -130,6 +149,7 @@ protected HiveQueryResultSet(Builder builder) throws SQLException { this.fetchSize = builder.fetchSize; columnNames = new ArrayList(); columnTypes = new ArrayList(); + columnAttributes = new ArrayList(); if (builder.retrieveSchema) { retrieveSchema(); } else { @@ -145,6 +165,32 @@ protected HiveQueryResultSet(Builder builder) throws SQLException { } /** + * Generate ColumnAttributes object from a TTypeQualifiers + * @param primitiveTypeEntry primitive type + * @return generated ColumnAttributes, or null + */ + private static JdbcColumn.ColumnAttributes getColumnAttributes( + TPrimitiveTypeEntry primitiveTypeEntry) { + JdbcColumn.ColumnAttributes ret = null; + if (primitiveTypeEntry.isSetTypeQualifiers()) { + TTypeQualifiers tq = primitiveTypeEntry.getTypeQualifiers(); + switch (primitiveTypeEntry.getType()) { + case VARCHAR_TYPE: + TTypeQualifierValue val = + tq.getQualifiers().get(TCLIServiceConstants.CHARACTER_MAXIMUM_LENGTH); + if (val != null) { + // precision is char length + ret = new JdbcColumn.ColumnAttributes(val.getI32Value(), 0); + } + break; + default: + break; + } + } + return ret; + } + + /** * Retrieve schema from the server */ private void retrieveSchema() throws SQLException { @@ -172,9 +218,11 @@ private void retrieveSchema() throws SQLException { } String columnName = columns.get(pos).getColumnName(); columnNames.add(columnName); - String columnTypeName = TYPE_NAMES.get( - columns.get(pos).getTypeDesc().getTypes().get(0).getPrimitiveEntry().getType()); + TPrimitiveTypeEntry primitiveTypeEntry = + columns.get(pos).getTypeDesc().getTypes().get(0).getPrimitiveEntry(); + String columnTypeName = TYPE_NAMES.get(primitiveTypeEntry.getType()); columnTypes.add(columnTypeName); + columnAttributes.add(getColumnAttributes(primitiveTypeEntry)); } } catch (SQLException eS) { throw eS; // rethrow the SQLException as is @@ -189,9 +237,11 @@ private void retrieveSchema() throws SQLException { * @param colNames * @param colTypes */ - public void setSchema(List colNames, List colTypes) { + public void setSchema(List colNames, List colTypes, + List colAttributes) { columnNames.addAll(colNames); columnTypes.addAll(colTypes); + columnAttributes.addAll(colAttributes); } @Override diff --git jdbc/src/java/org/apache/hive/jdbc/HiveResultSetMetaData.java jdbc/src/java/org/apache/hive/jdbc/HiveResultSetMetaData.java index ec6fee8..ceed72a 100644 --- jdbc/src/java/org/apache/hive/jdbc/HiveResultSetMetaData.java +++ jdbc/src/java/org/apache/hive/jdbc/HiveResultSetMetaData.java @@ -20,6 +20,7 @@ import java.sql.ResultSetMetaData; import java.sql.SQLException; +import java.util.Arrays; import java.util.List; import org.apache.hadoop.hive.serde.serdeConstants; @@ -31,11 +32,14 @@ public class HiveResultSetMetaData implements java.sql.ResultSetMetaData { private final List columnNames; private final List columnTypes; + private final List columnAttributes; public HiveResultSetMetaData(List columnNames, - List columnTypes) { + List columnTypes, + List columnAttributes) { this.columnNames = columnNames; this.columnTypes = columnTypes; + this.columnAttributes = columnAttributes; } public String getCatalogName(int column) throws SQLException { @@ -53,7 +57,7 @@ public int getColumnCount() throws SQLException { public int getColumnDisplaySize(int column) throws SQLException { int columnType = getColumnType(column); - return JdbcColumn.columnDisplaySize(columnType); + return JdbcColumn.columnDisplaySize(columnType, columnAttributes.get(column - 1)); } public String getColumnLabel(int column) throws SQLException { @@ -89,6 +93,8 @@ public String getColumnTypeName(int column) throws SQLException { String type = columnTypes.get(column - 1); if ("string".equalsIgnoreCase(type)) { return serdeConstants.STRING_TYPE_NAME; + } else if ("varchar".equalsIgnoreCase(type)) { + return serdeConstants.VARCHAR_TYPE_NAME; } else if ("float".equalsIgnoreCase(type)) { return serdeConstants.FLOAT_TYPE_NAME; } else if ("double".equalsIgnoreCase(type)) { @@ -127,13 +133,13 @@ public String getColumnTypeName(int column) throws SQLException { public int getPrecision(int column) throws SQLException { int columnType = getColumnType(column); - return JdbcColumn.columnPrecision(columnType); + return JdbcColumn.columnPrecision(columnType, columnAttributes.get(column - 1)); } public int getScale(int column) throws SQLException { int columnType = getColumnType(column); - return JdbcColumn.columnScale(columnType); + return JdbcColumn.columnScale(columnType, columnAttributes.get(column - 1)); } public String getSchemaName(int column) throws SQLException { diff --git jdbc/src/java/org/apache/hive/jdbc/JdbcColumn.java jdbc/src/java/org/apache/hive/jdbc/JdbcColumn.java index 5553d7d..7760713 100644 --- jdbc/src/java/org/apache/hive/jdbc/JdbcColumn.java +++ jdbc/src/java/org/apache/hive/jdbc/JdbcColumn.java @@ -33,6 +33,19 @@ private final String comment; private final int ordinalPos; + static class ColumnAttributes { + public int precision = 0; + public int scale = 0; + + public ColumnAttributes() { + } + + public ColumnAttributes(int precision, int scale) { + this.precision = precision; + this.scale = scale; + } + } + JdbcColumn(String columnName, String tableName, String tableCatalog , String type, String comment, int ordinalPos) { this.columnName = columnName; @@ -63,22 +76,26 @@ public Integer getSqlType() throws SQLException { return Utils.hiveTypeToSqlType(type); } - static int columnDisplaySize(int columnType) throws SQLException { + static int columnDisplaySize(int columnType, ColumnAttributes columnAttributes) + throws SQLException { // according to hiveTypeToSqlType possible options are: switch(columnType) { case Types.BOOLEAN: - return columnPrecision(columnType); + return columnPrecision(columnType, columnAttributes); case Types.VARCHAR: + if (columnAttributes != null) { + return columnAttributes.precision; + } return Integer.MAX_VALUE; // hive has no max limit for strings case Types.TINYINT: case Types.SMALLINT: case Types.INTEGER: case Types.BIGINT: - return columnPrecision(columnType) + 1; // allow +/- + return columnPrecision(columnType, columnAttributes) + 1; // allow +/- case Types.DATE: return 10; case Types.TIMESTAMP: - return columnPrecision(columnType); + return columnPrecision(columnType, columnAttributes); // see http://download.oracle.com/javase/6/docs/api/constant-values.html#java.lang.Float.MAX_EXPONENT case Types.FLOAT: @@ -87,18 +104,25 @@ static int columnDisplaySize(int columnType) throws SQLException { case Types.DOUBLE: return 25; // e.g. -(17#).e-#### case Types.DECIMAL: + if (columnAttributes != null) { + return columnAttributes.precision + 2; // '-' sign and '.' + } return Integer.MAX_VALUE; default: throw new SQLException("Invalid column type: " + columnType); } } - static int columnPrecision(int columnType) throws SQLException { + static int columnPrecision(int columnType, ColumnAttributes columnAttributes) + throws SQLException { // according to hiveTypeToSqlType possible options are: switch(columnType) { case Types.BOOLEAN: return 1; case Types.VARCHAR: + if (columnAttributes != null) { + return columnAttributes.precision; + } return Integer.MAX_VALUE; // hive has no max limit for strings case Types.TINYINT: return 3; @@ -117,13 +141,17 @@ static int columnPrecision(int columnType) throws SQLException { case Types.TIMESTAMP: return 29; case Types.DECIMAL: + if (columnAttributes != null) { + return columnAttributes.precision; + } return Integer.MAX_VALUE; default: throw new SQLException("Invalid column type: " + columnType); } } - static int columnScale(int columnType) throws SQLException { + static int columnScale(int columnType, ColumnAttributes columnAttributes) + throws SQLException { // according to hiveTypeToSqlType possible options are: switch(columnType) { case Types.BOOLEAN: @@ -141,6 +169,9 @@ static int columnScale(int columnType) throws SQLException { case Types.TIMESTAMP: return 9; case Types.DECIMAL: + if (columnAttributes != null) { + return columnAttributes.scale; + } return Integer.MAX_VALUE; default: throw new SQLException("Invalid column type: " + columnType); @@ -148,13 +179,13 @@ static int columnScale(int columnType) throws SQLException { } public Integer getColumnSize() throws SQLException { - int precision = columnPrecision(Utils.hiveTypeToSqlType(type)); + int precision = columnPrecision(Utils.hiveTypeToSqlType(type), null); return precision == 0 ? null : precision; } public Integer getDecimalDigits() throws SQLException { - return columnScale(Utils.hiveTypeToSqlType(type)); + return columnScale(Utils.hiveTypeToSqlType(type), null); } public Integer getNumPrecRadix() { diff --git jdbc/src/java/org/apache/hive/jdbc/Utils.java jdbc/src/java/org/apache/hive/jdbc/Utils.java index 3df3bd7..754e107 100644 --- jdbc/src/java/org/apache/hive/jdbc/Utils.java +++ jdbc/src/java/org/apache/hive/jdbc/Utils.java @@ -114,6 +114,8 @@ public void setSessionVars(Map sessionVars) { public static int hiveTypeToSqlType(String type) throws SQLException { if ("string".equalsIgnoreCase(type)) { return Types.VARCHAR; + } else if ("varchar".equalsIgnoreCase(type)) { + return Types.VARCHAR; } else if ("float".equalsIgnoreCase(type)) { return Types.FLOAT; } else if ("double".equalsIgnoreCase(type)) { diff --git jdbc/src/test/org/apache/hive/jdbc/TestJdbcDriver2.java jdbc/src/test/org/apache/hive/jdbc/TestJdbcDriver2.java index bb36337..3cfb054 100644 --- jdbc/src/test/org/apache/hive/jdbc/TestJdbcDriver2.java +++ jdbc/src/test/org/apache/hive/jdbc/TestJdbcDriver2.java @@ -157,7 +157,9 @@ protected void setUp() throws Exception { + " c17 timestamp, " + " c18 decimal, " + " c19 binary, " - + " c20 date) comment'" + dataTypeTableComment + + " c20 date," + + " c21 varchar(20)" + + ") comment'" + dataTypeTableComment +"' partitioned by (dt STRING)"); stmt.execute("load data local inpath '" @@ -575,6 +577,7 @@ public void testDataTypes() throws Exception { assertEquals(null, res.getString(19)); assertEquals(null, res.getString(20)); assertEquals(null, res.getDate(20)); + assertEquals(null, res.getString(21)); // row 2 assertTrue(res.next()); @@ -600,6 +603,7 @@ public void testDataTypes() throws Exception { assertEquals(null, res.getString(19)); assertEquals(null, res.getString(20)); assertEquals(null, res.getDate(20)); + assertEquals(null, res.getString(21)); // row 3 assertTrue(res.next()); @@ -625,6 +629,7 @@ public void testDataTypes() throws Exception { assertEquals("abcd", res.getString(19)); assertEquals("2013-01-01", res.getString(20)); assertEquals("2013-01-01", res.getDate(20).toString()); + assertEquals("abc123", res.getString(21)); // test getBoolean rules on non-boolean columns assertEquals(true, res.getBoolean(1)); @@ -1088,14 +1093,14 @@ public void testResultSetMetaData() throws SQLException { ResultSet res = stmt.executeQuery( "select c1, c2, c3, c4, c5 as a, c6, c7, c8, c9, c10, c11, c12, " + - "c1*2, sentences(null, null, null) as b, c17, c18, c20 from " + dataTypeTableName + + "c1*2, sentences(null, null, null) as b, c17, c18, c20, c21 from " + dataTypeTableName + " limit 1"); ResultSetMetaData meta = res.getMetaData(); ResultSet colRS = con.getMetaData().getColumns(null, null, dataTypeTableName.toLowerCase(), null); - assertEquals(17, meta.getColumnCount()); + assertEquals(18, meta.getColumnCount()); assertTrue(colRS.next()); @@ -1303,6 +1308,14 @@ public void testResultSetMetaData() throws SQLException { assertEquals(10, meta.getPrecision(17)); assertEquals(0, meta.getScale(17)); + assertEquals("c21", meta.getColumnName(18)); + assertEquals(Types.VARCHAR, meta.getColumnType(18)); + assertEquals("varchar", meta.getColumnTypeName(18)); + // varchar columns should have correct display size/precision + assertEquals(20, meta.getColumnDisplaySize(18)); + assertEquals(20, meta.getPrecision(18)); + assertEquals(0, meta.getScale(18)); + for (int i = 1; i <= meta.getColumnCount(); i++) { assertFalse(meta.isAutoIncrement(i)); assertFalse(meta.isCurrency(i)); diff --git service/if/TCLIService.thrift service/if/TCLIService.thrift index ae79668..6e20375 100644 --- service/if/TCLIService.thrift +++ service/if/TCLIService.thrift @@ -42,6 +42,9 @@ enum TProtocolVersion { // V2 adds support for asynchronous execution HIVE_CLI_SERVICE_PROTOCOL_V2 + + // V3 add varchar type, primitive type qualifiers + HIVE_CLI_SERVICE_PROTOCOL_V3 } enum TTypeId { @@ -62,7 +65,8 @@ enum TTypeId { USER_DEFINED_TYPE, DECIMAL_TYPE, NULL_TYPE, - DATE_TYPE + DATE_TYPE, + VARCHAR_TYPE } const set PRIMITIVE_TYPES = [ @@ -79,6 +83,7 @@ const set PRIMITIVE_TYPES = [ TTypeId.DECIMAL_TYPE, TTypeId.NULL_TYPE TTypeId.DATE_TYPE + TTypeId.VARCHAR_TYPE ] const set COMPLEX_TYPES = [ @@ -112,6 +117,7 @@ const map TYPE_NAMES = { TTypeId.DECIMAL_TYPE: "DECIMAL", TTypeId.NULL_TYPE: "NULL" TTypeId.DATE_TYPE: "DATE" + TTypeId.VARCHAR_TYPE: "VARCHAR" } // Thrift does not support recursively defined types or forward declarations, @@ -159,11 +165,25 @@ const map TYPE_NAMES = { typedef i32 TTypeEntryPtr +// Valid TTypeQualifiers key names +const string CHARACTER_MAXIMUM_LENGTH = "characterMaximumLength" + +union TTypeQualifierValue { + 1: optional i32 i32Value + 2: optional string stringValue +} + +// Type qualifiers for primitive type. +struct TTypeQualifiers { + 1: required map qualifiers +} + // Type entry for a primitive type. struct TPrimitiveTypeEntry { // The primitive type token. This must satisfy the condition // that type is in the PRIMITIVE_TYPES set. 1: required TTypeId type + 2: optional TTypeQualifiers typeQualifiers } // Type entry for an ARRAY type. @@ -458,7 +478,7 @@ struct TOperationHandle { // which operations may be executed. struct TOpenSessionReq { // The version of the HiveServer2 protocol that the client is using. - 1: required TProtocolVersion client_protocol = TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V2 + 1: required TProtocolVersion client_protocol = TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V3 // Username and password for authentication. // Depending on the authentication scheme being used, @@ -477,7 +497,7 @@ struct TOpenSessionResp { 1: required TStatus status // The protocol version that the server is using. - 2: required TProtocolVersion serverProtocolVersion = TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V2 + 2: required TProtocolVersion serverProtocolVersion = TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V3 // Session Handle 3: optional TSessionHandle sessionHandle diff --git service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp index 7284cc5..d085b30 100644 --- service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp +++ service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp @@ -24,6 +24,7 @@ TCLIServiceConstants::TCLIServiceConstants() { PRIMITIVE_TYPES.insert((TTypeId::type)15); PRIMITIVE_TYPES.insert((TTypeId::type)16); PRIMITIVE_TYPES.insert((TTypeId::type)17); + PRIMITIVE_TYPES.insert((TTypeId::type)18); COMPLEX_TYPES.insert((TTypeId::type)10); COMPLEX_TYPES.insert((TTypeId::type)11); @@ -51,6 +52,9 @@ TCLIServiceConstants::TCLIServiceConstants() { TYPE_NAMES.insert(std::make_pair((TTypeId::type)15, "DECIMAL")); TYPE_NAMES.insert(std::make_pair((TTypeId::type)16, "NULL")); TYPE_NAMES.insert(std::make_pair((TTypeId::type)17, "DATE")); + TYPE_NAMES.insert(std::make_pair((TTypeId::type)18, "VARCHAR")); + + CHARACTER_MAXIMUM_LENGTH = "characterMaximumLength"; } diff --git service/src/gen/thrift/gen-cpp/TCLIService_constants.h service/src/gen/thrift/gen-cpp/TCLIService_constants.h index cd63739..7471811 100644 --- service/src/gen/thrift/gen-cpp/TCLIService_constants.h +++ service/src/gen/thrift/gen-cpp/TCLIService_constants.h @@ -19,6 +19,7 @@ class TCLIServiceConstants { std::set COMPLEX_TYPES; std::set COLLECTION_TYPES; std::map TYPE_NAMES; + std::string CHARACTER_MAXIMUM_LENGTH; }; extern const TCLIServiceConstants g_TCLIService_constants; diff --git service/src/gen/thrift/gen-cpp/TCLIService_types.cpp service/src/gen/thrift/gen-cpp/TCLIService_types.cpp index d2bfded..a3fd46c 100644 --- service/src/gen/thrift/gen-cpp/TCLIService_types.cpp +++ service/src/gen/thrift/gen-cpp/TCLIService_types.cpp @@ -12,13 +12,15 @@ namespace apache { namespace hive { namespace service { namespace cli { namespac int _kTProtocolVersionValues[] = { TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V1, - TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V2 + TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V2, + TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V3 }; const char* _kTProtocolVersionNames[] = { "HIVE_CLI_SERVICE_PROTOCOL_V1", - "HIVE_CLI_SERVICE_PROTOCOL_V2" + "HIVE_CLI_SERVICE_PROTOCOL_V2", + "HIVE_CLI_SERVICE_PROTOCOL_V3" }; -const std::map _TProtocolVersion_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kTProtocolVersionValues, _kTProtocolVersionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +const std::map _TProtocolVersion_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kTProtocolVersionValues, _kTProtocolVersionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); int _kTTypeIdValues[] = { TTypeId::BOOLEAN_TYPE, @@ -38,7 +40,8 @@ int _kTTypeIdValues[] = { TTypeId::USER_DEFINED_TYPE, TTypeId::DECIMAL_TYPE, TTypeId::NULL_TYPE, - TTypeId::DATE_TYPE + TTypeId::DATE_TYPE, + TTypeId::VARCHAR_TYPE }; const char* _kTTypeIdNames[] = { "BOOLEAN_TYPE", @@ -58,9 +61,10 @@ const char* _kTTypeIdNames[] = { "USER_DEFINED_TYPE", "DECIMAL_TYPE", "NULL_TYPE", - "DATE_TYPE" + "DATE_TYPE", + "VARCHAR_TYPE" }; -const std::map _TTypeId_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(18, _kTTypeIdValues, _kTTypeIdNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +const std::map _TTypeId_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(19, _kTTypeIdValues, _kTTypeIdNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); int _kTStatusCodeValues[] = { TStatusCode::SUCCESS_STATUS, @@ -242,8 +246,173 @@ const char* _kTFetchOrientationNames[] = { }; const std::map _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}; +const char* TTypeQualifierValue::ascii_fingerprint = "A7801670116150C65ACA43E6F679BA79"; +const uint8_t TTypeQualifierValue::binary_fingerprint[16] = {0xA7,0x80,0x16,0x70,0x11,0x61,0x50,0xC6,0x5A,0xCA,0x43,0xE6,0xF6,0x79,0xBA,0x79}; + +uint32_t TTypeQualifierValue::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->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; + 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); +} + +const char* TTypeQualifiers::ascii_fingerprint = "6C72981CFA989214285648FA8C196C47"; +const uint8_t TTypeQualifiers::binary_fingerprint[16] = {0x6C,0x72,0x98,0x1C,0xFA,0x98,0x92,0x14,0x28,0x56,0x48,0xFA,0x8C,0x19,0x6C,0x47}; + +uint32_t TTypeQualifiers::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_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 _size0; + ::apache::thrift::protocol::TType _ktype1; + ::apache::thrift::protocol::TType _vtype2; + xfer += iprot->readMapBegin(_ktype1, _vtype2, _size0); + uint32_t _i4; + for (_i4 = 0; _i4 < _size0; ++_i4) + { + std::string _key5; + xfer += iprot->readString(_key5); + TTypeQualifierValue& _val6 = this->qualifiers[_key5]; + xfer += _val6.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; + 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(this->qualifiers.size())); + std::map ::const_iterator _iter7; + for (_iter7 = this->qualifiers.begin(); _iter7 != this->qualifiers.end(); ++_iter7) + { + xfer += oprot->writeString(_iter7->first); + xfer += _iter7->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); +} + +const char* TPrimitiveTypeEntry::ascii_fingerprint = "755674F6A5C8EB47868686AE386FBC1C"; +const uint8_t TPrimitiveTypeEntry::binary_fingerprint[16] = {0x75,0x56,0x74,0xF6,0xA5,0xC8,0xEB,0x47,0x86,0x86,0x86,0xAE,0x38,0x6F,0xBC,0x1C}; uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { @@ -268,14 +437,22 @@ uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast0; - xfer += iprot->readI32(ecast0); - this->type = (TTypeId::type)ecast0; + int32_t ecast8; + xfer += iprot->readI32(ecast8); + this->type = (TTypeId::type)ecast8; 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; @@ -298,6 +475,11 @@ uint32_t TPrimitiveTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot 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; @@ -306,6 +488,8 @@ uint32_t TPrimitiveTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b) { using ::std::swap; swap(a.type, b.type); + swap(a.typeQualifiers, b.typeQualifiers); + swap(a.__isset, b.__isset); } const char* TArrayTypeEntry::ascii_fingerprint = "E86CACEB22240450EDCBEFC3A83970E4"; @@ -480,17 +664,17 @@ uint32_t TStructTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + 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 _key6; - xfer += iprot->readString(_key6); - TTypeEntryPtr& _val7 = this->nameToTypePtr[_key6]; - xfer += iprot->readI32(_val7); + std::string _key14; + xfer += iprot->readString(_key14); + TTypeEntryPtr& _val15 = this->nameToTypePtr[_key14]; + xfer += iprot->readI32(_val15); } xfer += iprot->readMapEnd(); } @@ -520,11 +704,11 @@ uint32_t TStructTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) c 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(this->nameToTypePtr.size())); - std::map ::const_iterator _iter8; - for (_iter8 = this->nameToTypePtr.begin(); _iter8 != this->nameToTypePtr.end(); ++_iter8) + std::map ::const_iterator _iter16; + for (_iter16 = this->nameToTypePtr.begin(); _iter16 != this->nameToTypePtr.end(); ++_iter16) { - xfer += oprot->writeString(_iter8->first); - xfer += oprot->writeI32(_iter8->second); + xfer += oprot->writeString(_iter16->first); + xfer += oprot->writeI32(_iter16->second); } xfer += oprot->writeMapEnd(); } @@ -568,17 +752,17 @@ uint32_t TUnionTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size17; + ::apache::thrift::protocol::TType _ktype18; + ::apache::thrift::protocol::TType _vtype19; + xfer += iprot->readMapBegin(_ktype18, _vtype19, _size17); + uint32_t _i21; + for (_i21 = 0; _i21 < _size17; ++_i21) { - std::string _key14; - xfer += iprot->readString(_key14); - TTypeEntryPtr& _val15 = this->nameToTypePtr[_key14]; - xfer += iprot->readI32(_val15); + std::string _key22; + xfer += iprot->readString(_key22); + TTypeEntryPtr& _val23 = this->nameToTypePtr[_key22]; + xfer += iprot->readI32(_val23); } xfer += iprot->readMapEnd(); } @@ -608,11 +792,11 @@ uint32_t TUnionTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) co 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(this->nameToTypePtr.size())); - std::map ::const_iterator _iter16; - for (_iter16 = this->nameToTypePtr.begin(); _iter16 != this->nameToTypePtr.end(); ++_iter16) + std::map ::const_iterator _iter24; + for (_iter24 = this->nameToTypePtr.begin(); _iter24 != this->nameToTypePtr.end(); ++_iter24) { - xfer += oprot->writeString(_iter16->first); - xfer += oprot->writeI32(_iter16->second); + xfer += oprot->writeString(_iter24->first); + xfer += oprot->writeI32(_iter24->second); } xfer += oprot->writeMapEnd(); } @@ -692,8 +876,8 @@ void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b) { 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}; +const char* TTypeEntry::ascii_fingerprint = "2FE56D9097E325DAA7E933738C6D325F"; +const uint8_t TTypeEntry::binary_fingerprint[16] = {0x2F,0xE5,0x6D,0x90,0x97,0xE3,0x25,0xDA,0xA7,0xE9,0x33,0x73,0x8C,0x6D,0x32,0x5F}; uint32_t TTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { @@ -819,8 +1003,8 @@ void swap(TTypeEntry &a, TTypeEntry &b) { 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}; +const char* TTypeDesc::ascii_fingerprint = "90B3C5A0B73419A84E85E0E48C452AA5"; +const uint8_t TTypeDesc::binary_fingerprint[16] = {0x90,0xB3,0xC5,0xA0,0xB7,0x34,0x19,0xA8,0x4E,0x85,0xE0,0xE4,0x8C,0x45,0x2A,0xA5}; uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* iprot) { @@ -847,14 +1031,14 @@ uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size25; + ::apache::thrift::protocol::TType _etype28; + xfer += iprot->readListBegin(_etype28, _size25); + this->types.resize(_size25); + uint32_t _i29; + for (_i29 = 0; _i29 < _size25; ++_i29) { - xfer += this->types[_i21].read(iprot); + xfer += this->types[_i29].read(iprot); } xfer += iprot->readListEnd(); } @@ -884,10 +1068,10 @@ uint32_t TTypeDesc::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("types", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->types.size())); - std::vector ::const_iterator _iter22; - for (_iter22 = this->types.begin(); _iter22 != this->types.end(); ++_iter22) + std::vector ::const_iterator _iter30; + for (_iter30 = this->types.begin(); _iter30 != this->types.end(); ++_iter30) { - xfer += (*_iter22).write(oprot); + xfer += (*_iter30).write(oprot); } xfer += oprot->writeListEnd(); } @@ -903,8 +1087,8 @@ void swap(TTypeDesc &a, TTypeDesc &b) { 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}; +const char* TColumnDesc::ascii_fingerprint = "EABED9009D5FCABFCA65612069F2A849"; +const uint8_t TColumnDesc::binary_fingerprint[16] = {0xEA,0xBE,0xD9,0x00,0x9D,0x5F,0xCA,0xBF,0xCA,0x65,0x61,0x20,0x69,0xF2,0xA8,0x49}; uint32_t TColumnDesc::read(::apache::thrift::protocol::TProtocol* iprot) { @@ -1014,8 +1198,8 @@ void swap(TColumnDesc &a, TColumnDesc &b) { 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}; +const char* TTableSchema::ascii_fingerprint = "7A1811E49313E5977107FC667B20E39D"; +const uint8_t TTableSchema::binary_fingerprint[16] = {0x7A,0x18,0x11,0xE4,0x93,0x13,0xE5,0x97,0x71,0x07,0xFC,0x66,0x7B,0x20,0xE3,0x9D}; uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* iprot) { @@ -1042,14 +1226,14 @@ uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size31; + ::apache::thrift::protocol::TType _etype34; + xfer += iprot->readListBegin(_etype34, _size31); + this->columns.resize(_size31); + uint32_t _i35; + for (_i35 = 0; _i35 < _size31; ++_i35) { - xfer += this->columns[_i27].read(iprot); + xfer += this->columns[_i35].read(iprot); } xfer += iprot->readListEnd(); } @@ -1079,10 +1263,10 @@ uint32_t TTableSchema::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->columns.size())); - std::vector ::const_iterator _iter28; - for (_iter28 = this->columns.begin(); _iter28 != this->columns.end(); ++_iter28) + std::vector ::const_iterator _iter36; + for (_iter36 = this->columns.begin(); _iter36 != this->columns.end(); ++_iter36) { - xfer += (*_iter28).write(oprot); + xfer += (*_iter36).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1566,14 +1750,14 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size37; + ::apache::thrift::protocol::TType _etype40; + xfer += iprot->readListBegin(_etype40, _size37); + this->boolColumn.resize(_size37); + uint32_t _i41; + for (_i41 = 0; _i41 < _size37; ++_i41) { - xfer += this->boolColumn[_i33].read(iprot); + xfer += this->boolColumn[_i41].read(iprot); } xfer += iprot->readListEnd(); } @@ -1586,14 +1770,14 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size42; + ::apache::thrift::protocol::TType _etype45; + xfer += iprot->readListBegin(_etype45, _size42); + this->byteColumn.resize(_size42); + uint32_t _i46; + for (_i46 = 0; _i46 < _size42; ++_i46) { - xfer += this->byteColumn[_i38].read(iprot); + xfer += this->byteColumn[_i46].read(iprot); } xfer += iprot->readListEnd(); } @@ -1606,14 +1790,14 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size47; + ::apache::thrift::protocol::TType _etype50; + xfer += iprot->readListBegin(_etype50, _size47); + this->i16Column.resize(_size47); + uint32_t _i51; + for (_i51 = 0; _i51 < _size47; ++_i51) { - xfer += this->i16Column[_i43].read(iprot); + xfer += this->i16Column[_i51].read(iprot); } xfer += iprot->readListEnd(); } @@ -1626,14 +1810,14 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size52; + ::apache::thrift::protocol::TType _etype55; + xfer += iprot->readListBegin(_etype55, _size52); + this->i32Column.resize(_size52); + uint32_t _i56; + for (_i56 = 0; _i56 < _size52; ++_i56) { - xfer += this->i32Column[_i48].read(iprot); + xfer += this->i32Column[_i56].read(iprot); } xfer += iprot->readListEnd(); } @@ -1646,14 +1830,14 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size57; + ::apache::thrift::protocol::TType _etype60; + xfer += iprot->readListBegin(_etype60, _size57); + this->i64Column.resize(_size57); + uint32_t _i61; + for (_i61 = 0; _i61 < _size57; ++_i61) { - xfer += this->i64Column[_i53].read(iprot); + xfer += this->i64Column[_i61].read(iprot); } xfer += iprot->readListEnd(); } @@ -1666,14 +1850,14 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size62; + ::apache::thrift::protocol::TType _etype65; + xfer += iprot->readListBegin(_etype65, _size62); + this->doubleColumn.resize(_size62); + uint32_t _i66; + for (_i66 = 0; _i66 < _size62; ++_i66) { - xfer += this->doubleColumn[_i58].read(iprot); + xfer += this->doubleColumn[_i66].read(iprot); } xfer += iprot->readListEnd(); } @@ -1686,14 +1870,14 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size67; + ::apache::thrift::protocol::TType _etype70; + xfer += iprot->readListBegin(_etype70, _size67); + this->stringColumn.resize(_size67); + uint32_t _i71; + for (_i71 = 0; _i71 < _size67; ++_i71) { - xfer += this->stringColumn[_i63].read(iprot); + xfer += this->stringColumn[_i71].read(iprot); } xfer += iprot->readListEnd(); } @@ -1721,10 +1905,10 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("boolColumn", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->boolColumn.size())); - std::vector ::const_iterator _iter64; - for (_iter64 = this->boolColumn.begin(); _iter64 != this->boolColumn.end(); ++_iter64) + std::vector ::const_iterator _iter72; + for (_iter72 = this->boolColumn.begin(); _iter72 != this->boolColumn.end(); ++_iter72) { - xfer += (*_iter64).write(oprot); + xfer += (*_iter72).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1733,10 +1917,10 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("byteColumn", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->byteColumn.size())); - std::vector ::const_iterator _iter65; - for (_iter65 = this->byteColumn.begin(); _iter65 != this->byteColumn.end(); ++_iter65) + std::vector ::const_iterator _iter73; + for (_iter73 = this->byteColumn.begin(); _iter73 != this->byteColumn.end(); ++_iter73) { - xfer += (*_iter65).write(oprot); + xfer += (*_iter73).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1745,10 +1929,10 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("i16Column", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->i16Column.size())); - std::vector ::const_iterator _iter66; - for (_iter66 = this->i16Column.begin(); _iter66 != this->i16Column.end(); ++_iter66) + std::vector ::const_iterator _iter74; + for (_iter74 = this->i16Column.begin(); _iter74 != this->i16Column.end(); ++_iter74) { - xfer += (*_iter66).write(oprot); + xfer += (*_iter74).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1757,10 +1941,10 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("i32Column", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->i32Column.size())); - std::vector ::const_iterator _iter67; - for (_iter67 = this->i32Column.begin(); _iter67 != this->i32Column.end(); ++_iter67) + std::vector ::const_iterator _iter75; + for (_iter75 = this->i32Column.begin(); _iter75 != this->i32Column.end(); ++_iter75) { - xfer += (*_iter67).write(oprot); + xfer += (*_iter75).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1769,10 +1953,10 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("i64Column", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->i64Column.size())); - std::vector ::const_iterator _iter68; - for (_iter68 = this->i64Column.begin(); _iter68 != this->i64Column.end(); ++_iter68) + std::vector ::const_iterator _iter76; + for (_iter76 = this->i64Column.begin(); _iter76 != this->i64Column.end(); ++_iter76) { - xfer += (*_iter68).write(oprot); + xfer += (*_iter76).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1781,10 +1965,10 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("doubleColumn", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->doubleColumn.size())); - std::vector ::const_iterator _iter69; - for (_iter69 = this->doubleColumn.begin(); _iter69 != this->doubleColumn.end(); ++_iter69) + std::vector ::const_iterator _iter77; + for (_iter77 = this->doubleColumn.begin(); _iter77 != this->doubleColumn.end(); ++_iter77) { - xfer += (*_iter69).write(oprot); + xfer += (*_iter77).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1793,10 +1977,10 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("stringColumn", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->stringColumn.size())); - std::vector ::const_iterator _iter70; - for (_iter70 = this->stringColumn.begin(); _iter70 != this->stringColumn.end(); ++_iter70) + std::vector ::const_iterator _iter78; + for (_iter78 = this->stringColumn.begin(); _iter78 != this->stringColumn.end(); ++_iter78) { - xfer += (*_iter70).write(oprot); + xfer += (*_iter78).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1987,14 +2171,14 @@ uint32_t TRow::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size79; + ::apache::thrift::protocol::TType _etype82; + xfer += iprot->readListBegin(_etype82, _size79); + this->colVals.resize(_size79); + uint32_t _i83; + for (_i83 = 0; _i83 < _size79; ++_i83) { - xfer += this->colVals[_i75].read(iprot); + xfer += this->colVals[_i83].read(iprot); } xfer += iprot->readListEnd(); } @@ -2024,10 +2208,10 @@ uint32_t TRow::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("colVals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colVals.size())); - std::vector ::const_iterator _iter76; - for (_iter76 = this->colVals.begin(); _iter76 != this->colVals.end(); ++_iter76) + std::vector ::const_iterator _iter84; + for (_iter84 = this->colVals.begin(); _iter84 != this->colVals.end(); ++_iter84) { - xfer += (*_iter76).write(oprot); + xfer += (*_iter84).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2080,14 +2264,14 @@ uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size85; + ::apache::thrift::protocol::TType _etype88; + xfer += iprot->readListBegin(_etype88, _size85); + this->rows.resize(_size85); + uint32_t _i89; + for (_i89 = 0; _i89 < _size85; ++_i89) { - xfer += this->rows[_i81].read(iprot); + xfer += this->rows[_i89].read(iprot); } xfer += iprot->readListEnd(); } @@ -2100,14 +2284,14 @@ uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size90; + ::apache::thrift::protocol::TType _etype93; + xfer += iprot->readListBegin(_etype93, _size90); + this->columns.resize(_size90); + uint32_t _i94; + for (_i94 = 0; _i94 < _size90; ++_i94) { - xfer += this->columns[_i86].read(iprot); + xfer += this->columns[_i94].read(iprot); } xfer += iprot->readListEnd(); } @@ -2143,10 +2327,10 @@ uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->rows.size())); - std::vector ::const_iterator _iter87; - for (_iter87 = this->rows.begin(); _iter87 != this->rows.end(); ++_iter87) + std::vector ::const_iterator _iter95; + for (_iter95 = this->rows.begin(); _iter95 != this->rows.end(); ++_iter95) { - xfer += (*_iter87).write(oprot); + xfer += (*_iter95).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2156,10 +2340,10 @@ uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->columns.size())); - std::vector ::const_iterator _iter88; - for (_iter88 = this->columns.begin(); _iter88 != this->columns.end(); ++_iter88) + std::vector ::const_iterator _iter96; + for (_iter96 = this->columns.begin(); _iter96 != this->columns.end(); ++_iter96) { - xfer += (*_iter88).write(oprot); + xfer += (*_iter96).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2204,9 +2388,9 @@ uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast89; - xfer += iprot->readI32(ecast89); - this->statusCode = (TStatusCode::type)ecast89; + int32_t ecast97; + xfer += iprot->readI32(ecast97); + this->statusCode = (TStatusCode::type)ecast97; isset_statusCode = true; } else { xfer += iprot->skip(ftype); @@ -2216,14 +2400,14 @@ uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size98; + ::apache::thrift::protocol::TType _etype101; + xfer += iprot->readListBegin(_etype101, _size98); + this->infoMessages.resize(_size98); + uint32_t _i102; + for (_i102 = 0; _i102 < _size98; ++_i102) { - xfer += iprot->readString(this->infoMessages[_i94]); + xfer += iprot->readString(this->infoMessages[_i102]); } xfer += iprot->readListEnd(); } @@ -2282,10 +2466,10 @@ uint32_t TStatus::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("infoMessages", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->infoMessages.size())); - std::vector ::const_iterator _iter95; - for (_iter95 = this->infoMessages.begin(); _iter95 != this->infoMessages.end(); ++_iter95) + std::vector ::const_iterator _iter103; + for (_iter103 = this->infoMessages.begin(); _iter103 != this->infoMessages.end(); ++_iter103) { - xfer += oprot->writeString((*_iter95)); + xfer += oprot->writeString((*_iter103)); } xfer += oprot->writeListEnd(); } @@ -2501,9 +2685,9 @@ uint32_t TOperationHandle::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast96; - xfer += iprot->readI32(ecast96); - this->operationType = (TOperationType::type)ecast96; + int32_t ecast104; + xfer += iprot->readI32(ecast104); + this->operationType = (TOperationType::type)ecast104; isset_operationType = true; } else { xfer += iprot->skip(ftype); @@ -2604,9 +2788,9 @@ uint32_t TOpenSessionReq::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast97; - xfer += iprot->readI32(ecast97); - this->client_protocol = (TProtocolVersion::type)ecast97; + int32_t ecast105; + xfer += iprot->readI32(ecast105); + this->client_protocol = (TProtocolVersion::type)ecast105; isset_client_protocol = true; } else { xfer += iprot->skip(ftype); @@ -2632,17 +2816,17 @@ uint32_t TOpenSessionReq::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size106; + ::apache::thrift::protocol::TType _ktype107; + ::apache::thrift::protocol::TType _vtype108; + xfer += iprot->readMapBegin(_ktype107, _vtype108, _size106); + uint32_t _i110; + for (_i110 = 0; _i110 < _size106; ++_i110) { - std::string _key103; - xfer += iprot->readString(_key103); - std::string& _val104 = this->configuration[_key103]; - xfer += iprot->readString(_val104); + std::string _key111; + xfer += iprot->readString(_key111); + std::string& _val112 = this->configuration[_key111]; + xfer += iprot->readString(_val112); } xfer += iprot->readMapEnd(); } @@ -2687,11 +2871,11 @@ uint32_t TOpenSessionReq::write(::apache::thrift::protocol::TProtocol* oprot) co 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(this->configuration.size())); - std::map ::const_iterator _iter105; - for (_iter105 = this->configuration.begin(); _iter105 != this->configuration.end(); ++_iter105) + std::map ::const_iterator _iter113; + for (_iter113 = this->configuration.begin(); _iter113 != this->configuration.end(); ++_iter113) { - xfer += oprot->writeString(_iter105->first); - xfer += oprot->writeString(_iter105->second); + xfer += oprot->writeString(_iter113->first); + xfer += oprot->writeString(_iter113->second); } xfer += oprot->writeMapEnd(); } @@ -2746,9 +2930,9 @@ uint32_t TOpenSessionResp::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast106; - xfer += iprot->readI32(ecast106); - this->serverProtocolVersion = (TProtocolVersion::type)ecast106; + int32_t ecast114; + xfer += iprot->readI32(ecast114); + this->serverProtocolVersion = (TProtocolVersion::type)ecast114; isset_serverProtocolVersion = true; } else { xfer += iprot->skip(ftype); @@ -2766,17 +2950,17 @@ uint32_t TOpenSessionResp::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size115; + ::apache::thrift::protocol::TType _ktype116; + ::apache::thrift::protocol::TType _vtype117; + xfer += iprot->readMapBegin(_ktype116, _vtype117, _size115); + uint32_t _i119; + for (_i119 = 0; _i119 < _size115; ++_i119) { - std::string _key112; - xfer += iprot->readString(_key112); - std::string& _val113 = this->configuration[_key112]; - xfer += iprot->readString(_val113); + std::string _key120; + xfer += iprot->readString(_key120); + std::string& _val121 = this->configuration[_key120]; + xfer += iprot->readString(_val121); } xfer += iprot->readMapEnd(); } @@ -2822,11 +3006,11 @@ uint32_t TOpenSessionResp::write(::apache::thrift::protocol::TProtocol* oprot) c 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(this->configuration.size())); - std::map ::const_iterator _iter114; - for (_iter114 = this->configuration.begin(); _iter114 != this->configuration.end(); ++_iter114) + std::map ::const_iterator _iter122; + for (_iter122 = this->configuration.begin(); _iter122 != this->configuration.end(); ++_iter122) { - xfer += oprot->writeString(_iter114->first); - xfer += oprot->writeString(_iter114->second); + xfer += oprot->writeString(_iter122->first); + xfer += oprot->writeString(_iter122->second); } xfer += oprot->writeMapEnd(); } @@ -3136,9 +3320,9 @@ uint32_t TGetInfoReq::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast115; - xfer += iprot->readI32(ecast115); - this->infoType = (TGetInfoType::type)ecast115; + int32_t ecast123; + xfer += iprot->readI32(ecast123); + this->infoType = (TGetInfoType::type)ecast123; isset_infoType = true; } else { xfer += iprot->skip(ftype); @@ -3308,17 +3492,17 @@ uint32_t TExecuteStatementReq::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_MAP) { { this->confOverlay.clear(); - uint32_t _size116; - ::apache::thrift::protocol::TType _ktype117; - ::apache::thrift::protocol::TType _vtype118; - xfer += iprot->readMapBegin(_ktype117, _vtype118, _size116); - uint32_t _i120; - for (_i120 = 0; _i120 < _size116; ++_i120) + uint32_t _size124; + ::apache::thrift::protocol::TType _ktype125; + ::apache::thrift::protocol::TType _vtype126; + xfer += iprot->readMapBegin(_ktype125, _vtype126, _size124); + uint32_t _i128; + for (_i128 = 0; _i128 < _size124; ++_i128) { - std::string _key121; - xfer += iprot->readString(_key121); - std::string& _val122 = this->confOverlay[_key121]; - xfer += iprot->readString(_val122); + std::string _key129; + xfer += iprot->readString(_key129); + std::string& _val130 = this->confOverlay[_key129]; + xfer += iprot->readString(_val130); } xfer += iprot->readMapEnd(); } @@ -3367,11 +3551,11 @@ uint32_t TExecuteStatementReq::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("confOverlay", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->confOverlay.size())); - std::map ::const_iterator _iter123; - for (_iter123 = this->confOverlay.begin(); _iter123 != this->confOverlay.end(); ++_iter123) + std::map ::const_iterator _iter131; + for (_iter131 = this->confOverlay.begin(); _iter131 != this->confOverlay.end(); ++_iter131) { - xfer += oprot->writeString(_iter123->first); - xfer += oprot->writeString(_iter123->second); + xfer += oprot->writeString(_iter131->first); + xfer += oprot->writeString(_iter131->second); } xfer += oprot->writeMapEnd(); } @@ -3993,14 +4177,14 @@ uint32_t TGetTablesReq::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableTypes.clear(); - uint32_t _size124; - ::apache::thrift::protocol::TType _etype127; - xfer += iprot->readListBegin(_etype127, _size124); - this->tableTypes.resize(_size124); - uint32_t _i128; - for (_i128 = 0; _i128 < _size124; ++_i128) + uint32_t _size132; + ::apache::thrift::protocol::TType _etype135; + xfer += iprot->readListBegin(_etype135, _size132); + this->tableTypes.resize(_size132); + uint32_t _i136; + for (_i136 = 0; _i136 < _size132; ++_i136) { - xfer += iprot->readString(this->tableTypes[_i128]); + xfer += iprot->readString(this->tableTypes[_i136]); } xfer += iprot->readListEnd(); } @@ -4050,10 +4234,10 @@ uint32_t TGetTablesReq::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldBegin("tableTypes", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tableTypes.size())); - std::vector ::const_iterator _iter129; - for (_iter129 = this->tableTypes.begin(); _iter129 != this->tableTypes.end(); ++_iter129) + std::vector ::const_iterator _iter137; + for (_iter137 = this->tableTypes.begin(); _iter137 != this->tableTypes.end(); ++_iter137) { - xfer += oprot->writeString((*_iter129)); + xfer += oprot->writeString((*_iter137)); } xfer += oprot->writeListEnd(); } @@ -4782,9 +4966,9 @@ uint32_t TGetOperationStatusResp::read(::apache::thrift::protocol::TProtocol* ip break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast130; - xfer += iprot->readI32(ecast130); - this->operationState = (TOperationState::type)ecast130; + int32_t ecast138; + xfer += iprot->readI32(ecast138); + this->operationState = (TOperationState::type)ecast138; this->__isset.operationState = true; } else { xfer += iprot->skip(ftype); @@ -5149,8 +5333,8 @@ void swap(TGetResultSetMetadataReq &a, TGetResultSetMetadataReq &b) { swap(a.operationHandle, b.operationHandle); } -const char* TGetResultSetMetadataResp::ascii_fingerprint = "8778316D0AFC17584F192162BFF2AEDE"; -const uint8_t TGetResultSetMetadataResp::binary_fingerprint[16] = {0x87,0x78,0x31,0x6D,0x0A,0xFC,0x17,0x58,0x4F,0x19,0x21,0x62,0xBF,0xF2,0xAE,0xDE}; +const char* TGetResultSetMetadataResp::ascii_fingerprint = "42CD49B7F49CC1B6D4E6F5FA2D7BE812"; +const uint8_t TGetResultSetMetadataResp::binary_fingerprint[16] = {0x42,0xCD,0x49,0xB7,0xF4,0x9C,0xC1,0xB6,0xD4,0xE6,0xF5,0xFA,0x2D,0x7B,0xE8,0x12}; uint32_t TGetResultSetMetadataResp::read(::apache::thrift::protocol::TProtocol* iprot) { @@ -5264,9 +5448,9 @@ uint32_t TFetchResultsReq::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast131; - xfer += iprot->readI32(ecast131); - this->orientation = (TFetchOrientation::type)ecast131; + int32_t ecast139; + xfer += iprot->readI32(ecast139); + this->orientation = (TFetchOrientation::type)ecast139; isset_orientation = true; } else { xfer += iprot->skip(ftype); diff --git service/src/gen/thrift/gen-cpp/TCLIService_types.h service/src/gen/thrift/gen-cpp/TCLIService_types.h index 8fa3633..490b393 100644 --- service/src/gen/thrift/gen-cpp/TCLIService_types.h +++ service/src/gen/thrift/gen-cpp/TCLIService_types.h @@ -19,7 +19,8 @@ namespace apache { namespace hive { namespace service { namespace cli { namespac struct TProtocolVersion { enum type { HIVE_CLI_SERVICE_PROTOCOL_V1 = 0, - HIVE_CLI_SERVICE_PROTOCOL_V2 = 1 + HIVE_CLI_SERVICE_PROTOCOL_V2 = 1, + HIVE_CLI_SERVICE_PROTOCOL_V3 = 2 }; }; @@ -44,7 +45,8 @@ struct TTypeId { USER_DEFINED_TYPE = 14, DECIMAL_TYPE = 15, NULL_TYPE = 16, - DATE_TYPE = 17 + DATE_TYPE = 17, + VARCHAR_TYPE = 18 }; }; @@ -168,12 +170,110 @@ typedef std::string TPattern; typedef std::string TPatternOrIdentifier; +typedef struct _TTypeQualifierValue__isset { + _TTypeQualifierValue__isset() : i32Value(false), stringValue(false) {} + bool i32Value; + bool stringValue; +} _TTypeQualifierValue__isset; + +class TTypeQualifierValue { + public: + + static const char* ascii_fingerprint; // = "A7801670116150C65ACA43E6F679BA79"; + static const uint8_t binary_fingerprint[16]; // = {0xA7,0x80,0x16,0x70,0x11,0x61,0x50,0xC6,0x5A,0xCA,0x43,0xE6,0xF6,0x79,0xBA,0x79}; + + TTypeQualifierValue() : i32Value(0), stringValue() { + } + + virtual ~TTypeQualifierValue() throw() {} + + int32_t i32Value; + std::string stringValue; + + _TTypeQualifierValue__isset __isset; + + void __set_i32Value(const int32_t val) { + i32Value = val; + __isset.i32Value = true; + } + + void __set_stringValue(const std::string& val) { + stringValue = val; + __isset.stringValue = true; + } + + bool operator == (const TTypeQualifierValue & rhs) const + { + if (__isset.i32Value != rhs.__isset.i32Value) + return false; + else if (__isset.i32Value && !(i32Value == rhs.i32Value)) + return false; + if (__isset.stringValue != rhs.__isset.stringValue) + return false; + else if (__isset.stringValue && !(stringValue == rhs.stringValue)) + return false; + return true; + } + bool operator != (const TTypeQualifierValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TTypeQualifierValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(TTypeQualifierValue &a, TTypeQualifierValue &b); + + +class TTypeQualifiers { + public: + + static const char* ascii_fingerprint; // = "6C72981CFA989214285648FA8C196C47"; + static const uint8_t binary_fingerprint[16]; // = {0x6C,0x72,0x98,0x1C,0xFA,0x98,0x92,0x14,0x28,0x56,0x48,0xFA,0x8C,0x19,0x6C,0x47}; + + TTypeQualifiers() { + } + + virtual ~TTypeQualifiers() throw() {} + + std::map qualifiers; + + void __set_qualifiers(const std::map & val) { + qualifiers = val; + } + + bool operator == (const TTypeQualifiers & rhs) const + { + if (!(qualifiers == rhs.qualifiers)) + return false; + return true; + } + bool operator != (const TTypeQualifiers &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TTypeQualifiers & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(TTypeQualifiers &a, TTypeQualifiers &b); + +typedef struct _TPrimitiveTypeEntry__isset { + _TPrimitiveTypeEntry__isset() : typeQualifiers(false) {} + bool typeQualifiers; +} _TPrimitiveTypeEntry__isset; class TPrimitiveTypeEntry { public: - static const char* ascii_fingerprint; // = "8BBB3D0C3B370CB38F2D1340BB79F0AA"; - static const uint8_t binary_fingerprint[16]; // = {0x8B,0xBB,0x3D,0x0C,0x3B,0x37,0x0C,0xB3,0x8F,0x2D,0x13,0x40,0xBB,0x79,0xF0,0xAA}; + static const char* ascii_fingerprint; // = "755674F6A5C8EB47868686AE386FBC1C"; + static const uint8_t binary_fingerprint[16]; // = {0x75,0x56,0x74,0xF6,0xA5,0xC8,0xEB,0x47,0x86,0x86,0x86,0xAE,0x38,0x6F,0xBC,0x1C}; TPrimitiveTypeEntry() : type((TTypeId::type)0) { } @@ -181,15 +281,27 @@ class TPrimitiveTypeEntry { virtual ~TPrimitiveTypeEntry() throw() {} TTypeId::type type; + TTypeQualifiers typeQualifiers; + + _TPrimitiveTypeEntry__isset __isset; void __set_type(const TTypeId::type val) { type = val; } + void __set_typeQualifiers(const TTypeQualifiers& val) { + typeQualifiers = val; + __isset.typeQualifiers = true; + } + bool operator == (const TPrimitiveTypeEntry & rhs) const { if (!(type == rhs.type)) return false; + if (__isset.typeQualifiers != rhs.__isset.typeQualifiers) + return false; + else if (__isset.typeQualifiers && !(typeQualifiers == rhs.typeQualifiers)) + return false; return true; } bool operator != (const TPrimitiveTypeEntry &rhs) const { @@ -410,8 +522,8 @@ typedef struct _TTypeEntry__isset { class TTypeEntry { public: - static const char* ascii_fingerprint; // = "0C3ACE4054603E2D37B8BFEBA79F4159"; - static const uint8_t binary_fingerprint[16]; // = {0x0C,0x3A,0xCE,0x40,0x54,0x60,0x3E,0x2D,0x37,0xB8,0xBF,0xEB,0xA7,0x9F,0x41,0x59}; + static const char* ascii_fingerprint; // = "2FE56D9097E325DAA7E933738C6D325F"; + static const uint8_t binary_fingerprint[16]; // = {0x2F,0xE5,0x6D,0x90,0x97,0xE3,0x25,0xDA,0xA7,0xE9,0x33,0x73,0x8C,0x6D,0x32,0x5F}; TTypeEntry() { } @@ -484,8 +596,8 @@ void swap(TTypeEntry &a, TTypeEntry &b); class TTypeDesc { public: - static const char* ascii_fingerprint; // = "60CA5B8BACFCD38D1D3EC1F0E3F1C36A"; - static const uint8_t binary_fingerprint[16]; // = {0x60,0xCA,0x5B,0x8B,0xAC,0xFC,0xD3,0x8D,0x1D,0x3E,0xC1,0xF0,0xE3,0xF1,0xC3,0x6A}; + static const char* ascii_fingerprint; // = "90B3C5A0B73419A84E85E0E48C452AA5"; + static const uint8_t binary_fingerprint[16]; // = {0x90,0xB3,0xC5,0xA0,0xB7,0x34,0x19,0xA8,0x4E,0x85,0xE0,0xE4,0x8C,0x45,0x2A,0xA5}; TTypeDesc() { } @@ -525,8 +637,8 @@ typedef struct _TColumnDesc__isset { class TColumnDesc { public: - static const char* ascii_fingerprint; // = "0DF9A37B81B1EE73D35A0AC01F33A48D"; - static const uint8_t binary_fingerprint[16]; // = {0x0D,0xF9,0xA3,0x7B,0x81,0xB1,0xEE,0x73,0xD3,0x5A,0x0A,0xC0,0x1F,0x33,0xA4,0x8D}; + static const char* ascii_fingerprint; // = "EABED9009D5FCABFCA65612069F2A849"; + static const uint8_t binary_fingerprint[16]; // = {0xEA,0xBE,0xD9,0x00,0x9D,0x5F,0xCA,0xBF,0xCA,0x65,0x61,0x20,0x69,0xF2,0xA8,0x49}; TColumnDesc() : columnName(), position(0), comment() { } @@ -588,8 +700,8 @@ void swap(TColumnDesc &a, TColumnDesc &b); class TTableSchema { public: - static const char* ascii_fingerprint; // = "E67E789F1EF836E4B9FC922C788AFDC8"; - static const uint8_t binary_fingerprint[16]; // = {0xE6,0x7E,0x78,0x9F,0x1E,0xF8,0x36,0xE4,0xB9,0xFC,0x92,0x2C,0x78,0x8A,0xFD,0xC8}; + static const char* ascii_fingerprint; // = "7A1811E49313E5977107FC667B20E39D"; + static const uint8_t binary_fingerprint[16]; // = {0x7A,0x18,0x11,0xE4,0x93,0x13,0xE5,0x97,0x71,0x07,0xFC,0x66,0x7B,0x20,0xE3,0x9D}; TTableSchema() { } @@ -1469,8 +1581,8 @@ class TOpenSessionReq { static const char* ascii_fingerprint; // = "C8FD0F306A16C16BDA7B57F58BFAE5B2"; static const uint8_t binary_fingerprint[16]; // = {0xC8,0xFD,0x0F,0x30,0x6A,0x16,0xC1,0x6B,0xDA,0x7B,0x57,0xF5,0x8B,0xFA,0xE5,0xB2}; - TOpenSessionReq() : client_protocol((TProtocolVersion::type)1), username(), password() { - client_protocol = (TProtocolVersion::type)1; + TOpenSessionReq() : client_protocol((TProtocolVersion::type)2), username(), password() { + client_protocol = (TProtocolVersion::type)2; } @@ -1545,8 +1657,8 @@ class TOpenSessionResp { static const char* ascii_fingerprint; // = "CFE7D7F4E9EC671F2518ED74FEE9F163"; static const uint8_t binary_fingerprint[16]; // = {0xCF,0xE7,0xD7,0xF4,0xE9,0xEC,0x67,0x1F,0x25,0x18,0xED,0x74,0xFE,0xE9,0xF1,0x63}; - TOpenSessionResp() : serverProtocolVersion((TProtocolVersion::type)1) { - serverProtocolVersion = (TProtocolVersion::type)1; + TOpenSessionResp() : serverProtocolVersion((TProtocolVersion::type)2) { + serverProtocolVersion = (TProtocolVersion::type)2; } @@ -3047,8 +3159,8 @@ typedef struct _TGetResultSetMetadataResp__isset { class TGetResultSetMetadataResp { public: - static const char* ascii_fingerprint; // = "8778316D0AFC17584F192162BFF2AEDE"; - static const uint8_t binary_fingerprint[16]; // = {0x87,0x78,0x31,0x6D,0x0A,0xFC,0x17,0x58,0x4F,0x19,0x21,0x62,0xBF,0xF2,0xAE,0xDE}; + static const char* ascii_fingerprint; // = "42CD49B7F49CC1B6D4E6F5FA2D7BE812"; + static const uint8_t binary_fingerprint[16]; // = {0x42,0xCD,0x49,0xB7,0xF4,0x9C,0xC1,0xB6,0xD4,0xE6,0xF5,0xFA,0x2D,0x7B,0xE8,0x12}; TGetResultSetMetadataResp() { } diff --git service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/ThriftHive.java service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/ThriftHive.java index 745e6cc..1c44789 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/ThriftHive.java +++ service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/ThriftHive.java @@ -3023,7 +3023,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, fetchN_result struc struct.success = new ArrayList(_list0.size); for (int _i1 = 0; _i1 < _list0.size; ++_i1) { - String _elem2; // required + String _elem2; // optional _elem2 = iprot.readString(); struct.success.add(_elem2); } @@ -3122,7 +3122,7 @@ public void read(org.apache.thrift.protocol.TProtocol prot, fetchN_result struct struct.success = new ArrayList(_list5.size); for (int _i6 = 0; _i6 < _list5.size; ++_i6) { - String _elem7; // required + String _elem7; // optional _elem7 = iprot.readString(); struct.success.add(_elem7); } @@ -3785,7 +3785,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, fetchAll_result str struct.success = new ArrayList(_list8.size); for (int _i9 = 0; _i9 < _list8.size; ++_i9) { - String _elem10; // required + String _elem10; // optional _elem10 = iprot.readString(); struct.success.add(_elem10); } @@ -3884,7 +3884,7 @@ public void read(org.apache.thrift.protocol.TProtocol prot, fetchAll_result stru struct.success = new ArrayList(_list13.size); for (int _i14 = 0; _i14 < _list13.size; ++_i14) { - String _elem15; // required + String _elem15; // optional _elem15 = iprot.readString(); struct.success.add(_elem15); } diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCLIServiceConstants.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCLIServiceConstants.java index 83b73fa..4748e79 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCLIServiceConstants.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCLIServiceConstants.java @@ -48,6 +48,7 @@ PRIMITIVE_TYPES.add(org.apache.hive.service.cli.thrift.TTypeId.DECIMAL_TYPE); PRIMITIVE_TYPES.add(org.apache.hive.service.cli.thrift.TTypeId.NULL_TYPE); PRIMITIVE_TYPES.add(org.apache.hive.service.cli.thrift.TTypeId.DATE_TYPE); + PRIMITIVE_TYPES.add(org.apache.hive.service.cli.thrift.TTypeId.VARCHAR_TYPE); } public static final Set COMPLEX_TYPES = new HashSet(); @@ -84,6 +85,9 @@ TYPE_NAMES.put(org.apache.hive.service.cli.thrift.TTypeId.DECIMAL_TYPE, "DECIMAL"); TYPE_NAMES.put(org.apache.hive.service.cli.thrift.TTypeId.NULL_TYPE, "NULL"); TYPE_NAMES.put(org.apache.hive.service.cli.thrift.TTypeId.DATE_TYPE, "DATE"); + TYPE_NAMES.put(org.apache.hive.service.cli.thrift.TTypeId.VARCHAR_TYPE, "VARCHAR"); } + public static final String CHARACTER_MAXIMUM_LENGTH = "characterMaximumLength"; + } diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TColumn.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TColumn.java index 2b8af2c..497cc01 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TColumn.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TColumn.java @@ -255,14 +255,14 @@ protected Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol ip if (field.type == BOOL_COLUMN_FIELD_DESC.type) { List boolColumn; { - org.apache.thrift.protocol.TList _list36 = iprot.readListBegin(); - boolColumn = new ArrayList(_list36.size); - for (int _i37 = 0; _i37 < _list36.size; ++_i37) + org.apache.thrift.protocol.TList _list46 = iprot.readListBegin(); + boolColumn = new ArrayList(_list46.size); + for (int _i47 = 0; _i47 < _list46.size; ++_i47) { - TBoolValue _elem38; // required - _elem38 = new TBoolValue(); - _elem38.read(iprot); - boolColumn.add(_elem38); + TBoolValue _elem48; // optional + _elem48 = new TBoolValue(); + _elem48.read(iprot); + boolColumn.add(_elem48); } iprot.readListEnd(); } @@ -275,14 +275,14 @@ protected Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol ip if (field.type == BYTE_COLUMN_FIELD_DESC.type) { List byteColumn; { - org.apache.thrift.protocol.TList _list39 = iprot.readListBegin(); - byteColumn = new ArrayList(_list39.size); - for (int _i40 = 0; _i40 < _list39.size; ++_i40) + org.apache.thrift.protocol.TList _list49 = iprot.readListBegin(); + byteColumn = new ArrayList(_list49.size); + for (int _i50 = 0; _i50 < _list49.size; ++_i50) { - TByteValue _elem41; // required - _elem41 = new TByteValue(); - _elem41.read(iprot); - byteColumn.add(_elem41); + TByteValue _elem51; // optional + _elem51 = new TByteValue(); + _elem51.read(iprot); + byteColumn.add(_elem51); } iprot.readListEnd(); } @@ -295,14 +295,14 @@ protected Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol ip if (field.type == I16_COLUMN_FIELD_DESC.type) { List i16Column; { - org.apache.thrift.protocol.TList _list42 = iprot.readListBegin(); - i16Column = new ArrayList(_list42.size); - for (int _i43 = 0; _i43 < _list42.size; ++_i43) + org.apache.thrift.protocol.TList _list52 = iprot.readListBegin(); + i16Column = new ArrayList(_list52.size); + for (int _i53 = 0; _i53 < _list52.size; ++_i53) { - TI16Value _elem44; // required - _elem44 = new TI16Value(); - _elem44.read(iprot); - i16Column.add(_elem44); + TI16Value _elem54; // optional + _elem54 = new TI16Value(); + _elem54.read(iprot); + i16Column.add(_elem54); } iprot.readListEnd(); } @@ -315,14 +315,14 @@ protected Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol ip if (field.type == I32_COLUMN_FIELD_DESC.type) { List i32Column; { - org.apache.thrift.protocol.TList _list45 = iprot.readListBegin(); - i32Column = new ArrayList(_list45.size); - for (int _i46 = 0; _i46 < _list45.size; ++_i46) + org.apache.thrift.protocol.TList _list55 = iprot.readListBegin(); + i32Column = new ArrayList(_list55.size); + for (int _i56 = 0; _i56 < _list55.size; ++_i56) { - TI32Value _elem47; // required - _elem47 = new TI32Value(); - _elem47.read(iprot); - i32Column.add(_elem47); + TI32Value _elem57; // optional + _elem57 = new TI32Value(); + _elem57.read(iprot); + i32Column.add(_elem57); } iprot.readListEnd(); } @@ -335,14 +335,14 @@ protected Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol ip if (field.type == I64_COLUMN_FIELD_DESC.type) { List i64Column; { - org.apache.thrift.protocol.TList _list48 = iprot.readListBegin(); - i64Column = new ArrayList(_list48.size); - for (int _i49 = 0; _i49 < _list48.size; ++_i49) + org.apache.thrift.protocol.TList _list58 = iprot.readListBegin(); + i64Column = new ArrayList(_list58.size); + for (int _i59 = 0; _i59 < _list58.size; ++_i59) { - TI64Value _elem50; // required - _elem50 = new TI64Value(); - _elem50.read(iprot); - i64Column.add(_elem50); + TI64Value _elem60; // optional + _elem60 = new TI64Value(); + _elem60.read(iprot); + i64Column.add(_elem60); } iprot.readListEnd(); } @@ -355,14 +355,14 @@ protected Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol ip if (field.type == DOUBLE_COLUMN_FIELD_DESC.type) { List doubleColumn; { - org.apache.thrift.protocol.TList _list51 = iprot.readListBegin(); - doubleColumn = new ArrayList(_list51.size); - for (int _i52 = 0; _i52 < _list51.size; ++_i52) + org.apache.thrift.protocol.TList _list61 = iprot.readListBegin(); + doubleColumn = new ArrayList(_list61.size); + for (int _i62 = 0; _i62 < _list61.size; ++_i62) { - TDoubleValue _elem53; // required - _elem53 = new TDoubleValue(); - _elem53.read(iprot); - doubleColumn.add(_elem53); + TDoubleValue _elem63; // optional + _elem63 = new TDoubleValue(); + _elem63.read(iprot); + doubleColumn.add(_elem63); } iprot.readListEnd(); } @@ -375,14 +375,14 @@ protected Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol ip if (field.type == STRING_COLUMN_FIELD_DESC.type) { List stringColumn; { - org.apache.thrift.protocol.TList _list54 = iprot.readListBegin(); - stringColumn = new ArrayList(_list54.size); - for (int _i55 = 0; _i55 < _list54.size; ++_i55) + org.apache.thrift.protocol.TList _list64 = iprot.readListBegin(); + stringColumn = new ArrayList(_list64.size); + for (int _i65 = 0; _i65 < _list64.size; ++_i65) { - TStringValue _elem56; // required - _elem56 = new TStringValue(); - _elem56.read(iprot); - stringColumn.add(_elem56); + TStringValue _elem66; // optional + _elem66 = new TStringValue(); + _elem66.read(iprot); + stringColumn.add(_elem66); } iprot.readListEnd(); } @@ -406,9 +406,9 @@ protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol opr List boolColumn = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, boolColumn.size())); - for (TBoolValue _iter57 : boolColumn) + for (TBoolValue _iter67 : boolColumn) { - _iter57.write(oprot); + _iter67.write(oprot); } oprot.writeListEnd(); } @@ -417,9 +417,9 @@ protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol opr List byteColumn = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, byteColumn.size())); - for (TByteValue _iter58 : byteColumn) + for (TByteValue _iter68 : byteColumn) { - _iter58.write(oprot); + _iter68.write(oprot); } oprot.writeListEnd(); } @@ -428,9 +428,9 @@ protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol opr List i16Column = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, i16Column.size())); - for (TI16Value _iter59 : i16Column) + for (TI16Value _iter69 : i16Column) { - _iter59.write(oprot); + _iter69.write(oprot); } oprot.writeListEnd(); } @@ -439,9 +439,9 @@ protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol opr List i32Column = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, i32Column.size())); - for (TI32Value _iter60 : i32Column) + for (TI32Value _iter70 : i32Column) { - _iter60.write(oprot); + _iter70.write(oprot); } oprot.writeListEnd(); } @@ -450,9 +450,9 @@ protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol opr List i64Column = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, i64Column.size())); - for (TI64Value _iter61 : i64Column) + for (TI64Value _iter71 : i64Column) { - _iter61.write(oprot); + _iter71.write(oprot); } oprot.writeListEnd(); } @@ -461,9 +461,9 @@ protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol opr List doubleColumn = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, doubleColumn.size())); - for (TDoubleValue _iter62 : doubleColumn) + for (TDoubleValue _iter72 : doubleColumn) { - _iter62.write(oprot); + _iter72.write(oprot); } oprot.writeListEnd(); } @@ -472,9 +472,9 @@ protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol opr List stringColumn = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, stringColumn.size())); - for (TStringValue _iter63 : stringColumn) + for (TStringValue _iter73 : stringColumn) { - _iter63.write(oprot); + _iter73.write(oprot); } oprot.writeListEnd(); } @@ -492,14 +492,14 @@ protected Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot case BOOL_COLUMN: List boolColumn; { - org.apache.thrift.protocol.TList _list64 = iprot.readListBegin(); - boolColumn = new ArrayList(_list64.size); - for (int _i65 = 0; _i65 < _list64.size; ++_i65) + org.apache.thrift.protocol.TList _list74 = iprot.readListBegin(); + boolColumn = new ArrayList(_list74.size); + for (int _i75 = 0; _i75 < _list74.size; ++_i75) { - TBoolValue _elem66; // required - _elem66 = new TBoolValue(); - _elem66.read(iprot); - boolColumn.add(_elem66); + TBoolValue _elem76; // optional + _elem76 = new TBoolValue(); + _elem76.read(iprot); + boolColumn.add(_elem76); } iprot.readListEnd(); } @@ -507,14 +507,14 @@ protected Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot case BYTE_COLUMN: List byteColumn; { - org.apache.thrift.protocol.TList _list67 = iprot.readListBegin(); - byteColumn = new ArrayList(_list67.size); - for (int _i68 = 0; _i68 < _list67.size; ++_i68) + org.apache.thrift.protocol.TList _list77 = iprot.readListBegin(); + byteColumn = new ArrayList(_list77.size); + for (int _i78 = 0; _i78 < _list77.size; ++_i78) { - TByteValue _elem69; // required - _elem69 = new TByteValue(); - _elem69.read(iprot); - byteColumn.add(_elem69); + TByteValue _elem79; // optional + _elem79 = new TByteValue(); + _elem79.read(iprot); + byteColumn.add(_elem79); } iprot.readListEnd(); } @@ -522,14 +522,14 @@ protected Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot case I16_COLUMN: List i16Column; { - org.apache.thrift.protocol.TList _list70 = iprot.readListBegin(); - i16Column = new ArrayList(_list70.size); - for (int _i71 = 0; _i71 < _list70.size; ++_i71) + org.apache.thrift.protocol.TList _list80 = iprot.readListBegin(); + i16Column = new ArrayList(_list80.size); + for (int _i81 = 0; _i81 < _list80.size; ++_i81) { - TI16Value _elem72; // required - _elem72 = new TI16Value(); - _elem72.read(iprot); - i16Column.add(_elem72); + TI16Value _elem82; // optional + _elem82 = new TI16Value(); + _elem82.read(iprot); + i16Column.add(_elem82); } iprot.readListEnd(); } @@ -537,14 +537,14 @@ protected Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot case I32_COLUMN: List i32Column; { - org.apache.thrift.protocol.TList _list73 = iprot.readListBegin(); - i32Column = new ArrayList(_list73.size); - for (int _i74 = 0; _i74 < _list73.size; ++_i74) + org.apache.thrift.protocol.TList _list83 = iprot.readListBegin(); + i32Column = new ArrayList(_list83.size); + for (int _i84 = 0; _i84 < _list83.size; ++_i84) { - TI32Value _elem75; // required - _elem75 = new TI32Value(); - _elem75.read(iprot); - i32Column.add(_elem75); + TI32Value _elem85; // optional + _elem85 = new TI32Value(); + _elem85.read(iprot); + i32Column.add(_elem85); } iprot.readListEnd(); } @@ -552,14 +552,14 @@ protected Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot case I64_COLUMN: List i64Column; { - org.apache.thrift.protocol.TList _list76 = iprot.readListBegin(); - i64Column = new ArrayList(_list76.size); - for (int _i77 = 0; _i77 < _list76.size; ++_i77) + org.apache.thrift.protocol.TList _list86 = iprot.readListBegin(); + i64Column = new ArrayList(_list86.size); + for (int _i87 = 0; _i87 < _list86.size; ++_i87) { - TI64Value _elem78; // required - _elem78 = new TI64Value(); - _elem78.read(iprot); - i64Column.add(_elem78); + TI64Value _elem88; // optional + _elem88 = new TI64Value(); + _elem88.read(iprot); + i64Column.add(_elem88); } iprot.readListEnd(); } @@ -567,14 +567,14 @@ protected Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot case DOUBLE_COLUMN: List doubleColumn; { - org.apache.thrift.protocol.TList _list79 = iprot.readListBegin(); - doubleColumn = new ArrayList(_list79.size); - for (int _i80 = 0; _i80 < _list79.size; ++_i80) + org.apache.thrift.protocol.TList _list89 = iprot.readListBegin(); + doubleColumn = new ArrayList(_list89.size); + for (int _i90 = 0; _i90 < _list89.size; ++_i90) { - TDoubleValue _elem81; // required - _elem81 = new TDoubleValue(); - _elem81.read(iprot); - doubleColumn.add(_elem81); + TDoubleValue _elem91; // optional + _elem91 = new TDoubleValue(); + _elem91.read(iprot); + doubleColumn.add(_elem91); } iprot.readListEnd(); } @@ -582,14 +582,14 @@ protected Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot case STRING_COLUMN: List stringColumn; { - org.apache.thrift.protocol.TList _list82 = iprot.readListBegin(); - stringColumn = new ArrayList(_list82.size); - for (int _i83 = 0; _i83 < _list82.size; ++_i83) + org.apache.thrift.protocol.TList _list92 = iprot.readListBegin(); + stringColumn = new ArrayList(_list92.size); + for (int _i93 = 0; _i93 < _list92.size; ++_i93) { - TStringValue _elem84; // required - _elem84 = new TStringValue(); - _elem84.read(iprot); - stringColumn.add(_elem84); + TStringValue _elem94; // optional + _elem94 = new TStringValue(); + _elem94.read(iprot); + stringColumn.add(_elem94); } iprot.readListEnd(); } @@ -609,9 +609,9 @@ protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) List boolColumn = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, boolColumn.size())); - for (TBoolValue _iter85 : boolColumn) + for (TBoolValue _iter95 : boolColumn) { - _iter85.write(oprot); + _iter95.write(oprot); } oprot.writeListEnd(); } @@ -620,9 +620,9 @@ protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) List byteColumn = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, byteColumn.size())); - for (TByteValue _iter86 : byteColumn) + for (TByteValue _iter96 : byteColumn) { - _iter86.write(oprot); + _iter96.write(oprot); } oprot.writeListEnd(); } @@ -631,9 +631,9 @@ protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) List i16Column = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, i16Column.size())); - for (TI16Value _iter87 : i16Column) + for (TI16Value _iter97 : i16Column) { - _iter87.write(oprot); + _iter97.write(oprot); } oprot.writeListEnd(); } @@ -642,9 +642,9 @@ protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) List i32Column = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, i32Column.size())); - for (TI32Value _iter88 : i32Column) + for (TI32Value _iter98 : i32Column) { - _iter88.write(oprot); + _iter98.write(oprot); } oprot.writeListEnd(); } @@ -653,9 +653,9 @@ protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) List i64Column = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, i64Column.size())); - for (TI64Value _iter89 : i64Column) + for (TI64Value _iter99 : i64Column) { - _iter89.write(oprot); + _iter99.write(oprot); } oprot.writeListEnd(); } @@ -664,9 +664,9 @@ protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) List doubleColumn = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, doubleColumn.size())); - for (TDoubleValue _iter90 : doubleColumn) + for (TDoubleValue _iter100 : doubleColumn) { - _iter90.write(oprot); + _iter100.write(oprot); } oprot.writeListEnd(); } @@ -675,9 +675,9 @@ protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) List stringColumn = (List)value_; { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, stringColumn.size())); - for (TStringValue _iter91 : stringColumn) + for (TStringValue _iter101 : stringColumn) { - _iter91.write(oprot); + _iter101.write(oprot); } oprot.writeListEnd(); } diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TExecuteStatementReq.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TExecuteStatementReq.java index 6326d49..ea656ac 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TExecuteStatementReq.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TExecuteStatementReq.java @@ -624,15 +624,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TExecuteStatementRe case 3: // CONF_OVERLAY if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map144 = iprot.readMapBegin(); - struct.confOverlay = new HashMap(2*_map144.size); - for (int _i145 = 0; _i145 < _map144.size; ++_i145) + org.apache.thrift.protocol.TMap _map154 = iprot.readMapBegin(); + struct.confOverlay = new HashMap(2*_map154.size); + for (int _i155 = 0; _i155 < _map154.size; ++_i155) { - String _key146; // required - String _val147; // required - _key146 = iprot.readString(); - _val147 = iprot.readString(); - struct.confOverlay.put(_key146, _val147); + String _key156; // required + String _val157; // required + _key156 = iprot.readString(); + _val157 = iprot.readString(); + struct.confOverlay.put(_key156, _val157); } iprot.readMapEnd(); } @@ -677,10 +677,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TExecuteStatementR oprot.writeFieldBegin(CONF_OVERLAY_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.confOverlay.size())); - for (Map.Entry _iter148 : struct.confOverlay.entrySet()) + for (Map.Entry _iter158 : struct.confOverlay.entrySet()) { - oprot.writeString(_iter148.getKey()); - oprot.writeString(_iter148.getValue()); + oprot.writeString(_iter158.getKey()); + oprot.writeString(_iter158.getValue()); } oprot.writeMapEnd(); } @@ -722,10 +722,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TExecuteStatementRe if (struct.isSetConfOverlay()) { { oprot.writeI32(struct.confOverlay.size()); - for (Map.Entry _iter149 : struct.confOverlay.entrySet()) + for (Map.Entry _iter159 : struct.confOverlay.entrySet()) { - oprot.writeString(_iter149.getKey()); - oprot.writeString(_iter149.getValue()); + oprot.writeString(_iter159.getKey()); + oprot.writeString(_iter159.getValue()); } } } @@ -745,15 +745,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TExecuteStatementReq BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map150 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.confOverlay = new HashMap(2*_map150.size); - for (int _i151 = 0; _i151 < _map150.size; ++_i151) + org.apache.thrift.protocol.TMap _map160 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.confOverlay = new HashMap(2*_map160.size); + for (int _i161 = 0; _i161 < _map160.size; ++_i161) { - String _key152; // required - String _val153; // required - _key152 = iprot.readString(); - _val153 = iprot.readString(); - struct.confOverlay.put(_key152, _val153); + String _key162; // required + String _val163; // required + _key162 = iprot.readString(); + _val163 = iprot.readString(); + struct.confOverlay.put(_key162, _val163); } } struct.setConfOverlayIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetTablesReq.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetTablesReq.java index a59aa49..1cb5147 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetTablesReq.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetTablesReq.java @@ -711,13 +711,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TGetTablesReq struc case 5: // TABLE_TYPES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list154 = iprot.readListBegin(); - struct.tableTypes = new ArrayList(_list154.size); - for (int _i155 = 0; _i155 < _list154.size; ++_i155) + org.apache.thrift.protocol.TList _list164 = iprot.readListBegin(); + struct.tableTypes = new ArrayList(_list164.size); + for (int _i165 = 0; _i165 < _list164.size; ++_i165) { - String _elem156; // required - _elem156 = iprot.readString(); - struct.tableTypes.add(_elem156); + String _elem166; // optional + _elem166 = iprot.readString(); + struct.tableTypes.add(_elem166); } iprot.readListEnd(); } @@ -770,9 +770,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TGetTablesReq stru oprot.writeFieldBegin(TABLE_TYPES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tableTypes.size())); - for (String _iter157 : struct.tableTypes) + for (String _iter167 : struct.tableTypes) { - oprot.writeString(_iter157); + oprot.writeString(_iter167); } oprot.writeListEnd(); } @@ -823,9 +823,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TGetTablesReq struc if (struct.isSetTableTypes()) { { oprot.writeI32(struct.tableTypes.size()); - for (String _iter158 : struct.tableTypes) + for (String _iter168 : struct.tableTypes) { - oprot.writeString(_iter158); + oprot.writeString(_iter168); } } } @@ -852,13 +852,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TGetTablesReq struct } if (incoming.get(3)) { { - org.apache.thrift.protocol.TList _list159 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tableTypes = new ArrayList(_list159.size); - for (int _i160 = 0; _i160 < _list159.size; ++_i160) + org.apache.thrift.protocol.TList _list169 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tableTypes = new ArrayList(_list169.size); + for (int _i170 = 0; _i170 < _list169.size; ++_i170) { - String _elem161; // required - _elem161 = iprot.readString(); - struct.tableTypes.add(_elem161); + String _elem171; // optional + _elem171 = iprot.readString(); + struct.tableTypes.add(_elem171); } } struct.setTableTypesIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TOpenSessionReq.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TOpenSessionReq.java index 31c100a..8ab8297 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TOpenSessionReq.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TOpenSessionReq.java @@ -141,7 +141,7 @@ public String getFieldName() { } public TOpenSessionReq() { - this.client_protocol = org.apache.hive.service.cli.thrift.TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V2; + this.client_protocol = org.apache.hive.service.cli.thrift.TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V3; } @@ -188,7 +188,7 @@ public TOpenSessionReq deepCopy() { @Override public void clear() { - this.client_protocol = org.apache.hive.service.cli.thrift.TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V2; + this.client_protocol = org.apache.hive.service.cli.thrift.TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V3; this.username = null; this.password = null; @@ -638,15 +638,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TOpenSessionReq str case 4: // CONFIGURATION if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map124 = iprot.readMapBegin(); - struct.configuration = new HashMap(2*_map124.size); - for (int _i125 = 0; _i125 < _map124.size; ++_i125) + org.apache.thrift.protocol.TMap _map134 = iprot.readMapBegin(); + struct.configuration = new HashMap(2*_map134.size); + for (int _i135 = 0; _i135 < _map134.size; ++_i135) { - String _key126; // required - String _val127; // required - _key126 = iprot.readString(); - _val127 = iprot.readString(); - struct.configuration.put(_key126, _val127); + String _key136; // required + String _val137; // required + _key136 = iprot.readString(); + _val137 = iprot.readString(); + struct.configuration.put(_key136, _val137); } iprot.readMapEnd(); } @@ -692,10 +692,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TOpenSessionReq st oprot.writeFieldBegin(CONFIGURATION_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.configuration.size())); - for (Map.Entry _iter128 : struct.configuration.entrySet()) + for (Map.Entry _iter138 : struct.configuration.entrySet()) { - oprot.writeString(_iter128.getKey()); - oprot.writeString(_iter128.getValue()); + oprot.writeString(_iter138.getKey()); + oprot.writeString(_iter138.getValue()); } oprot.writeMapEnd(); } @@ -740,10 +740,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TOpenSessionReq str if (struct.isSetConfiguration()) { { oprot.writeI32(struct.configuration.size()); - for (Map.Entry _iter129 : struct.configuration.entrySet()) + for (Map.Entry _iter139 : struct.configuration.entrySet()) { - oprot.writeString(_iter129.getKey()); - oprot.writeString(_iter129.getValue()); + oprot.writeString(_iter139.getKey()); + oprot.writeString(_iter139.getValue()); } } } @@ -765,15 +765,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TOpenSessionReq stru } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map130 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.configuration = new HashMap(2*_map130.size); - for (int _i131 = 0; _i131 < _map130.size; ++_i131) + org.apache.thrift.protocol.TMap _map140 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.configuration = new HashMap(2*_map140.size); + for (int _i141 = 0; _i141 < _map140.size; ++_i141) { - String _key132; // required - String _val133; // required - _key132 = iprot.readString(); - _val133 = iprot.readString(); - struct.configuration.put(_key132, _val133); + String _key142; // required + String _val143; // required + _key142 = iprot.readString(); + _val143 = iprot.readString(); + struct.configuration.put(_key142, _val143); } } struct.setConfigurationIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TOpenSessionResp.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TOpenSessionResp.java index e80a7b3..5d353f7 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TOpenSessionResp.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TOpenSessionResp.java @@ -141,7 +141,7 @@ public String getFieldName() { } public TOpenSessionResp() { - this.serverProtocolVersion = org.apache.hive.service.cli.thrift.TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V2; + this.serverProtocolVersion = org.apache.hive.service.cli.thrift.TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V3; } @@ -191,7 +191,7 @@ public TOpenSessionResp deepCopy() { @Override public void clear() { this.status = null; - this.serverProtocolVersion = org.apache.hive.service.cli.thrift.TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V2; + this.serverProtocolVersion = org.apache.hive.service.cli.thrift.TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V3; this.sessionHandle = null; this.configuration = null; @@ -650,15 +650,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TOpenSessionResp st case 4: // CONFIGURATION if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map134 = iprot.readMapBegin(); - struct.configuration = new HashMap(2*_map134.size); - for (int _i135 = 0; _i135 < _map134.size; ++_i135) + org.apache.thrift.protocol.TMap _map144 = iprot.readMapBegin(); + struct.configuration = new HashMap(2*_map144.size); + for (int _i145 = 0; _i145 < _map144.size; ++_i145) { - String _key136; // required - String _val137; // required - _key136 = iprot.readString(); - _val137 = iprot.readString(); - struct.configuration.put(_key136, _val137); + String _key146; // required + String _val147; // required + _key146 = iprot.readString(); + _val147 = iprot.readString(); + struct.configuration.put(_key146, _val147); } iprot.readMapEnd(); } @@ -702,10 +702,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TOpenSessionResp s oprot.writeFieldBegin(CONFIGURATION_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.configuration.size())); - for (Map.Entry _iter138 : struct.configuration.entrySet()) + for (Map.Entry _iter148 : struct.configuration.entrySet()) { - oprot.writeString(_iter138.getKey()); - oprot.writeString(_iter138.getValue()); + oprot.writeString(_iter148.getKey()); + oprot.writeString(_iter148.getValue()); } oprot.writeMapEnd(); } @@ -745,10 +745,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TOpenSessionResp st if (struct.isSetConfiguration()) { { oprot.writeI32(struct.configuration.size()); - for (Map.Entry _iter139 : struct.configuration.entrySet()) + for (Map.Entry _iter149 : struct.configuration.entrySet()) { - oprot.writeString(_iter139.getKey()); - oprot.writeString(_iter139.getValue()); + oprot.writeString(_iter149.getKey()); + oprot.writeString(_iter149.getValue()); } } } @@ -770,15 +770,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TOpenSessionResp str } if (incoming.get(1)) { { - org.apache.thrift.protocol.TMap _map140 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.configuration = new HashMap(2*_map140.size); - for (int _i141 = 0; _i141 < _map140.size; ++_i141) + org.apache.thrift.protocol.TMap _map150 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.configuration = new HashMap(2*_map150.size); + for (int _i151 = 0; _i151 < _map150.size; ++_i151) { - String _key142; // required - String _val143; // required - _key142 = iprot.readString(); - _val143 = iprot.readString(); - struct.configuration.put(_key142, _val143); + String _key152; // required + String _val153; // required + _key152 = iprot.readString(); + _val153 = iprot.readString(); + struct.configuration.put(_key152, _val153); } } struct.setConfigurationIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TPrimitiveTypeEntry.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TPrimitiveTypeEntry.java index c0e2e28..9d2abf2 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TPrimitiveTypeEntry.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TPrimitiveTypeEntry.java @@ -35,6 +35,7 @@ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TPrimitiveTypeEntry"); private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short)1); + private static final org.apache.thrift.protocol.TField TYPE_QUALIFIERS_FIELD_DESC = new org.apache.thrift.protocol.TField("typeQualifiers", org.apache.thrift.protocol.TType.STRUCT, (short)2); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -43,6 +44,7 @@ } private TTypeId type; // required + private TTypeQualifiers typeQualifiers; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -50,7 +52,8 @@ * * @see TTypeId */ - TYPE((short)1, "type"); + TYPE((short)1, "type"), + TYPE_QUALIFIERS((short)2, "typeQualifiers"); private static final Map byName = new HashMap(); @@ -67,6 +70,8 @@ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // TYPE return TYPE; + case 2: // TYPE_QUALIFIERS + return TYPE_QUALIFIERS; default: return null; } @@ -107,11 +112,14 @@ public String getFieldName() { } // isset id assignments + private _Fields optionals[] = {_Fields.TYPE_QUALIFIERS}; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TTypeId.class))); + tmpMap.put(_Fields.TYPE_QUALIFIERS, new org.apache.thrift.meta_data.FieldMetaData("typeQualifiers", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTypeQualifiers.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TPrimitiveTypeEntry.class, metaDataMap); } @@ -133,6 +141,9 @@ public TPrimitiveTypeEntry(TPrimitiveTypeEntry other) { if (other.isSetType()) { this.type = other.type; } + if (other.isSetTypeQualifiers()) { + this.typeQualifiers = new TTypeQualifiers(other.typeQualifiers); + } } public TPrimitiveTypeEntry deepCopy() { @@ -142,6 +153,7 @@ public TPrimitiveTypeEntry deepCopy() { @Override public void clear() { this.type = null; + this.typeQualifiers = null; } /** @@ -175,6 +187,29 @@ public void setTypeIsSet(boolean value) { } } + public TTypeQualifiers getTypeQualifiers() { + return this.typeQualifiers; + } + + public void setTypeQualifiers(TTypeQualifiers typeQualifiers) { + this.typeQualifiers = typeQualifiers; + } + + public void unsetTypeQualifiers() { + this.typeQualifiers = null; + } + + /** Returns true if field typeQualifiers is set (has been assigned a value) and false otherwise */ + public boolean isSetTypeQualifiers() { + return this.typeQualifiers != null; + } + + public void setTypeQualifiersIsSet(boolean value) { + if (!value) { + this.typeQualifiers = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TYPE: @@ -185,6 +220,14 @@ public void setFieldValue(_Fields field, Object value) { } break; + case TYPE_QUALIFIERS: + if (value == null) { + unsetTypeQualifiers(); + } else { + setTypeQualifiers((TTypeQualifiers)value); + } + break; + } } @@ -193,6 +236,9 @@ public Object getFieldValue(_Fields field) { case TYPE: return getType(); + case TYPE_QUALIFIERS: + return getTypeQualifiers(); + } throw new IllegalStateException(); } @@ -206,6 +252,8 @@ public boolean isSet(_Fields field) { switch (field) { case TYPE: return isSetType(); + case TYPE_QUALIFIERS: + return isSetTypeQualifiers(); } throw new IllegalStateException(); } @@ -232,6 +280,15 @@ public boolean equals(TPrimitiveTypeEntry that) { return false; } + boolean this_present_typeQualifiers = true && this.isSetTypeQualifiers(); + boolean that_present_typeQualifiers = true && that.isSetTypeQualifiers(); + if (this_present_typeQualifiers || that_present_typeQualifiers) { + if (!(this_present_typeQualifiers && that_present_typeQualifiers)) + return false; + if (!this.typeQualifiers.equals(that.typeQualifiers)) + return false; + } + return true; } @@ -244,6 +301,11 @@ public int hashCode() { if (present_type) builder.append(type.getValue()); + boolean present_typeQualifiers = true && (isSetTypeQualifiers()); + builder.append(present_typeQualifiers); + if (present_typeQualifiers) + builder.append(typeQualifiers); + return builder.toHashCode(); } @@ -265,6 +327,16 @@ public int compareTo(TPrimitiveTypeEntry other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetTypeQualifiers()).compareTo(typedOther.isSetTypeQualifiers()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTypeQualifiers()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.typeQualifiers, typedOther.typeQualifiers); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -292,6 +364,16 @@ public String toString() { sb.append(this.type); } first = false; + if (isSetTypeQualifiers()) { + if (!first) sb.append(", "); + sb.append("typeQualifiers:"); + if (this.typeQualifiers == null) { + sb.append("null"); + } else { + sb.append(this.typeQualifiers); + } + first = false; + } sb.append(")"); return sb.toString(); } @@ -303,6 +385,9 @@ public void validate() throws org.apache.thrift.TException { } // check for sub-struct validity + if (typeQualifiers != null) { + typeQualifiers.validate(); + } } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { @@ -347,6 +432,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TPrimitiveTypeEntry org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 2: // TYPE_QUALIFIERS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.typeQualifiers = new TTypeQualifiers(); + struct.typeQualifiers.read(iprot); + struct.setTypeQualifiersIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -365,6 +459,13 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TPrimitiveTypeEntr oprot.writeI32(struct.type.getValue()); oprot.writeFieldEnd(); } + if (struct.typeQualifiers != null) { + if (struct.isSetTypeQualifiers()) { + oprot.writeFieldBegin(TYPE_QUALIFIERS_FIELD_DESC); + struct.typeQualifiers.write(oprot); + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -383,6 +484,14 @@ public TPrimitiveTypeEntryTupleScheme getScheme() { public void write(org.apache.thrift.protocol.TProtocol prot, TPrimitiveTypeEntry struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; oprot.writeI32(struct.type.getValue()); + BitSet optionals = new BitSet(); + if (struct.isSetTypeQualifiers()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetTypeQualifiers()) { + struct.typeQualifiers.write(oprot); + } } @Override @@ -390,6 +499,12 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TPrimitiveTypeEntry TTupleProtocol iprot = (TTupleProtocol) prot; struct.type = TTypeId.findByValue(iprot.readI32()); struct.setTypeIsSet(true); + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.typeQualifiers = new TTypeQualifiers(); + struct.typeQualifiers.read(iprot); + struct.setTypeQualifiersIsSet(true); + } } } diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TProtocolVersion.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TProtocolVersion.java index eb568d7..59e5ed1 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TProtocolVersion.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TProtocolVersion.java @@ -13,7 +13,8 @@ public enum TProtocolVersion implements org.apache.thrift.TEnum { HIVE_CLI_SERVICE_PROTOCOL_V1(0), - HIVE_CLI_SERVICE_PROTOCOL_V2(1); + HIVE_CLI_SERVICE_PROTOCOL_V2(1), + HIVE_CLI_SERVICE_PROTOCOL_V3(2); private final int value; @@ -38,6 +39,8 @@ public static TProtocolVersion findByValue(int value) { return HIVE_CLI_SERVICE_PROTOCOL_V1; case 1: return HIVE_CLI_SERVICE_PROTOCOL_V2; + case 2: + return HIVE_CLI_SERVICE_PROTOCOL_V3; default: return null; } diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRow.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRow.java index 82b2ae9..0b6772c 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRow.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRow.java @@ -350,14 +350,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TRow struct) throws case 1: // COL_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list92 = iprot.readListBegin(); - struct.colVals = new ArrayList(_list92.size); - for (int _i93 = 0; _i93 < _list92.size; ++_i93) + org.apache.thrift.protocol.TList _list102 = iprot.readListBegin(); + struct.colVals = new ArrayList(_list102.size); + for (int _i103 = 0; _i103 < _list102.size; ++_i103) { - TColumnValue _elem94; // required - _elem94 = new TColumnValue(); - _elem94.read(iprot); - struct.colVals.add(_elem94); + TColumnValue _elem104; // optional + _elem104 = new TColumnValue(); + _elem104.read(iprot); + struct.colVals.add(_elem104); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TRow struct) throw oprot.writeFieldBegin(COL_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.colVals.size())); - for (TColumnValue _iter95 : struct.colVals) + for (TColumnValue _iter105 : struct.colVals) { - _iter95.write(oprot); + _iter105.write(oprot); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TRow struct) throws TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.colVals.size()); - for (TColumnValue _iter96 : struct.colVals) + for (TColumnValue _iter106 : struct.colVals) { - _iter96.write(oprot); + _iter106.write(oprot); } } } @@ -421,14 +421,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TRow struct) throws public void read(org.apache.thrift.protocol.TProtocol prot, TRow struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list97 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.colVals = new ArrayList(_list97.size); - for (int _i98 = 0; _i98 < _list97.size; ++_i98) + org.apache.thrift.protocol.TList _list107 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.colVals = new ArrayList(_list107.size); + for (int _i108 = 0; _i108 < _list107.size; ++_i108) { - TColumnValue _elem99; // required - _elem99 = new TColumnValue(); - _elem99.read(iprot); - struct.colVals.add(_elem99); + TColumnValue _elem109; // optional + _elem109 = new TColumnValue(); + _elem109.read(iprot); + struct.colVals.add(_elem109); } } struct.setColValsIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRowSet.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRowSet.java index 2e5c5cc..db2262d 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRowSet.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRowSet.java @@ -545,14 +545,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TRowSet struct) thr case 2: // ROWS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list100 = iprot.readListBegin(); - struct.rows = new ArrayList(_list100.size); - for (int _i101 = 0; _i101 < _list100.size; ++_i101) + org.apache.thrift.protocol.TList _list110 = iprot.readListBegin(); + struct.rows = new ArrayList(_list110.size); + for (int _i111 = 0; _i111 < _list110.size; ++_i111) { - TRow _elem102; // required - _elem102 = new TRow(); - _elem102.read(iprot); - struct.rows.add(_elem102); + TRow _elem112; // optional + _elem112 = new TRow(); + _elem112.read(iprot); + struct.rows.add(_elem112); } iprot.readListEnd(); } @@ -564,14 +564,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TRowSet struct) thr case 3: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list103 = iprot.readListBegin(); - struct.columns = new ArrayList(_list103.size); - for (int _i104 = 0; _i104 < _list103.size; ++_i104) + org.apache.thrift.protocol.TList _list113 = iprot.readListBegin(); + struct.columns = new ArrayList(_list113.size); + for (int _i114 = 0; _i114 < _list113.size; ++_i114) { - TColumn _elem105; // required - _elem105 = new TColumn(); - _elem105.read(iprot); - struct.columns.add(_elem105); + TColumn _elem115; // optional + _elem115 = new TColumn(); + _elem115.read(iprot); + struct.columns.add(_elem115); } iprot.readListEnd(); } @@ -600,9 +600,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TRowSet struct) th oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.rows.size())); - for (TRow _iter106 : struct.rows) + for (TRow _iter116 : struct.rows) { - _iter106.write(oprot); + _iter116.write(oprot); } oprot.writeListEnd(); } @@ -613,9 +613,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TRowSet struct) th oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size())); - for (TColumn _iter107 : struct.columns) + for (TColumn _iter117 : struct.columns) { - _iter107.write(oprot); + _iter117.write(oprot); } oprot.writeListEnd(); } @@ -642,9 +642,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TRowSet struct) thr oprot.writeI64(struct.startRowOffset); { oprot.writeI32(struct.rows.size()); - for (TRow _iter108 : struct.rows) + for (TRow _iter118 : struct.rows) { - _iter108.write(oprot); + _iter118.write(oprot); } } BitSet optionals = new BitSet(); @@ -655,9 +655,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TRowSet struct) thr if (struct.isSetColumns()) { { oprot.writeI32(struct.columns.size()); - for (TColumn _iter109 : struct.columns) + for (TColumn _iter119 : struct.columns) { - _iter109.write(oprot); + _iter119.write(oprot); } } } @@ -669,28 +669,28 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TRowSet struct) thro struct.startRowOffset = iprot.readI64(); struct.setStartRowOffsetIsSet(true); { - org.apache.thrift.protocol.TList _list110 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.rows = new ArrayList(_list110.size); - for (int _i111 = 0; _i111 < _list110.size; ++_i111) + org.apache.thrift.protocol.TList _list120 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.rows = new ArrayList(_list120.size); + for (int _i121 = 0; _i121 < _list120.size; ++_i121) { - TRow _elem112; // required - _elem112 = new TRow(); - _elem112.read(iprot); - struct.rows.add(_elem112); + TRow _elem122; // optional + _elem122 = new TRow(); + _elem122.read(iprot); + struct.rows.add(_elem122); } } struct.setRowsIsSet(true); BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list113 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.columns = new ArrayList(_list113.size); - for (int _i114 = 0; _i114 < _list113.size; ++_i114) + org.apache.thrift.protocol.TList _list123 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.columns = new ArrayList(_list123.size); + for (int _i124 = 0; _i124 < _list123.size; ++_i124) { - TColumn _elem115; // required - _elem115 = new TColumn(); - _elem115.read(iprot); - struct.columns.add(_elem115); + TColumn _elem125; // optional + _elem125 = new TColumn(); + _elem125.read(iprot); + struct.columns.add(_elem125); } } struct.setColumnsIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TStatus.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TStatus.java index 300597e..81c2f16 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TStatus.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TStatus.java @@ -694,13 +694,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TStatus struct) thr case 2: // INFO_MESSAGES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list116 = iprot.readListBegin(); - struct.infoMessages = new ArrayList(_list116.size); - for (int _i117 = 0; _i117 < _list116.size; ++_i117) + org.apache.thrift.protocol.TList _list126 = iprot.readListBegin(); + struct.infoMessages = new ArrayList(_list126.size); + for (int _i127 = 0; _i127 < _list126.size; ++_i127) { - String _elem118; // required - _elem118 = iprot.readString(); - struct.infoMessages.add(_elem118); + String _elem128; // optional + _elem128 = iprot.readString(); + struct.infoMessages.add(_elem128); } iprot.readListEnd(); } @@ -756,9 +756,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TStatus struct) th oprot.writeFieldBegin(INFO_MESSAGES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.infoMessages.size())); - for (String _iter119 : struct.infoMessages) + for (String _iter129 : struct.infoMessages) { - oprot.writeString(_iter119); + oprot.writeString(_iter129); } oprot.writeListEnd(); } @@ -819,9 +819,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TStatus struct) thr if (struct.isSetInfoMessages()) { { oprot.writeI32(struct.infoMessages.size()); - for (String _iter120 : struct.infoMessages) + for (String _iter130 : struct.infoMessages) { - oprot.writeString(_iter120); + oprot.writeString(_iter130); } } } @@ -844,13 +844,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TStatus struct) thro BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list121 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.infoMessages = new ArrayList(_list121.size); - for (int _i122 = 0; _i122 < _list121.size; ++_i122) + org.apache.thrift.protocol.TList _list131 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.infoMessages = new ArrayList(_list131.size); + for (int _i132 = 0; _i132 < _list131.size; ++_i132) { - String _elem123; // required - _elem123 = iprot.readString(); - struct.infoMessages.add(_elem123); + String _elem133; // optional + _elem133 = iprot.readString(); + struct.infoMessages.add(_elem133); } } struct.setInfoMessagesIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TStructTypeEntry.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TStructTypeEntry.java index d12238f..20f5fb6 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TStructTypeEntry.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TStructTypeEntry.java @@ -355,15 +355,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TStructTypeEntry st case 1: // NAME_TO_TYPE_PTR if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map0 = iprot.readMapBegin(); - struct.nameToTypePtr = new HashMap(2*_map0.size); - for (int _i1 = 0; _i1 < _map0.size; ++_i1) + org.apache.thrift.protocol.TMap _map10 = iprot.readMapBegin(); + struct.nameToTypePtr = new HashMap(2*_map10.size); + for (int _i11 = 0; _i11 < _map10.size; ++_i11) { - String _key2; // required - int _val3; // required - _key2 = iprot.readString(); - _val3 = iprot.readI32(); - struct.nameToTypePtr.put(_key2, _val3); + String _key12; // required + int _val13; // required + _key12 = iprot.readString(); + _val13 = iprot.readI32(); + struct.nameToTypePtr.put(_key12, _val13); } iprot.readMapEnd(); } @@ -389,10 +389,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TStructTypeEntry s oprot.writeFieldBegin(NAME_TO_TYPE_PTR_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, struct.nameToTypePtr.size())); - for (Map.Entry _iter4 : struct.nameToTypePtr.entrySet()) + for (Map.Entry _iter14 : struct.nameToTypePtr.entrySet()) { - oprot.writeString(_iter4.getKey()); - oprot.writeI32(_iter4.getValue()); + oprot.writeString(_iter14.getKey()); + oprot.writeI32(_iter14.getValue()); } oprot.writeMapEnd(); } @@ -417,10 +417,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TStructTypeEntry st TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.nameToTypePtr.size()); - for (Map.Entry _iter5 : struct.nameToTypePtr.entrySet()) + for (Map.Entry _iter15 : struct.nameToTypePtr.entrySet()) { - oprot.writeString(_iter5.getKey()); - oprot.writeI32(_iter5.getValue()); + oprot.writeString(_iter15.getKey()); + oprot.writeI32(_iter15.getValue()); } } } @@ -429,15 +429,15 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TStructTypeEntry st public void read(org.apache.thrift.protocol.TProtocol prot, TStructTypeEntry struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TMap _map6 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.nameToTypePtr = new HashMap(2*_map6.size); - for (int _i7 = 0; _i7 < _map6.size; ++_i7) + org.apache.thrift.protocol.TMap _map16 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.nameToTypePtr = new HashMap(2*_map16.size); + for (int _i17 = 0; _i17 < _map16.size; ++_i17) { - String _key8; // required - int _val9; // required - _key8 = iprot.readString(); - _val9 = iprot.readI32(); - struct.nameToTypePtr.put(_key8, _val9); + String _key18; // required + int _val19; // required + _key18 = iprot.readString(); + _val19 = iprot.readI32(); + struct.nameToTypePtr.put(_key18, _val19); } } struct.setNameToTypePtrIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTableSchema.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTableSchema.java index 23238ad..ff5e54d 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTableSchema.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTableSchema.java @@ -350,14 +350,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TTableSchema struct case 1: // COLUMNS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list28 = iprot.readListBegin(); - struct.columns = new ArrayList(_list28.size); - for (int _i29 = 0; _i29 < _list28.size; ++_i29) + org.apache.thrift.protocol.TList _list38 = iprot.readListBegin(); + struct.columns = new ArrayList(_list38.size); + for (int _i39 = 0; _i39 < _list38.size; ++_i39) { - TColumnDesc _elem30; // required - _elem30 = new TColumnDesc(); - _elem30.read(iprot); - struct.columns.add(_elem30); + TColumnDesc _elem40; // optional + _elem40 = new TColumnDesc(); + _elem40.read(iprot); + struct.columns.add(_elem40); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TTableSchema struc oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size())); - for (TColumnDesc _iter31 : struct.columns) + for (TColumnDesc _iter41 : struct.columns) { - _iter31.write(oprot); + _iter41.write(oprot); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TTableSchema struct TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.columns.size()); - for (TColumnDesc _iter32 : struct.columns) + for (TColumnDesc _iter42 : struct.columns) { - _iter32.write(oprot); + _iter42.write(oprot); } } } @@ -421,14 +421,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TTableSchema struct public void read(org.apache.thrift.protocol.TProtocol prot, TTableSchema struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list33 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.columns = new ArrayList(_list33.size); - for (int _i34 = 0; _i34 < _list33.size; ++_i34) + org.apache.thrift.protocol.TList _list43 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.columns = new ArrayList(_list43.size); + for (int _i44 = 0; _i44 < _list43.size; ++_i44) { - TColumnDesc _elem35; // required - _elem35 = new TColumnDesc(); - _elem35.read(iprot); - struct.columns.add(_elem35); + TColumnDesc _elem45; // optional + _elem45 = new TColumnDesc(); + _elem45.read(iprot); + struct.columns.add(_elem45); } } struct.setColumnsIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeDesc.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeDesc.java index 973bddc..251f86a 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeDesc.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeDesc.java @@ -350,14 +350,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TTypeDesc struct) t case 1: // TYPES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list20 = iprot.readListBegin(); - struct.types = new ArrayList(_list20.size); - for (int _i21 = 0; _i21 < _list20.size; ++_i21) + org.apache.thrift.protocol.TList _list30 = iprot.readListBegin(); + struct.types = new ArrayList(_list30.size); + for (int _i31 = 0; _i31 < _list30.size; ++_i31) { - TTypeEntry _elem22; // required - _elem22 = new TTypeEntry(); - _elem22.read(iprot); - struct.types.add(_elem22); + TTypeEntry _elem32; // optional + _elem32 = new TTypeEntry(); + _elem32.read(iprot); + struct.types.add(_elem32); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TTypeDesc struct) oprot.writeFieldBegin(TYPES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.types.size())); - for (TTypeEntry _iter23 : struct.types) + for (TTypeEntry _iter33 : struct.types) { - _iter23.write(oprot); + _iter33.write(oprot); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TTypeDesc struct) t TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.types.size()); - for (TTypeEntry _iter24 : struct.types) + for (TTypeEntry _iter34 : struct.types) { - _iter24.write(oprot); + _iter34.write(oprot); } } } @@ -421,14 +421,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TTypeDesc struct) t public void read(org.apache.thrift.protocol.TProtocol prot, TTypeDesc struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list25 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.types = new ArrayList(_list25.size); - for (int _i26 = 0; _i26 < _list25.size; ++_i26) + org.apache.thrift.protocol.TList _list35 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.types = new ArrayList(_list35.size); + for (int _i36 = 0; _i36 < _list35.size; ++_i36) { - TTypeEntry _elem27; // required - _elem27 = new TTypeEntry(); - _elem27.read(iprot); - struct.types.add(_elem27); + TTypeEntry _elem37; // optional + _elem37 = new TTypeEntry(); + _elem37.read(iprot); + struct.types.add(_elem37); } } struct.setTypesIsSet(true); diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeId.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeId.java index aecc59e..be70a3a 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeId.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeId.java @@ -29,7 +29,8 @@ USER_DEFINED_TYPE(14), DECIMAL_TYPE(15), NULL_TYPE(16), - DATE_TYPE(17); + DATE_TYPE(17), + VARCHAR_TYPE(18); private final int value; @@ -86,6 +87,8 @@ public static TTypeId findByValue(int value) { return NULL_TYPE; case 17: return DATE_TYPE; + case 18: + return VARCHAR_TYPE; default: return null; } diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeQualifierValue.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeQualifierValue.java new file mode 100644 index 0000000..8c40687 --- /dev/null +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeQualifierValue.java @@ -0,0 +1,361 @@ +/** + * Autogenerated by Thrift Compiler (0.9.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hive.service.cli.thrift; + +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class TTypeQualifierValue extends org.apache.thrift.TUnion { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTypeQualifierValue"); + private static final org.apache.thrift.protocol.TField I32_VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("i32Value", org.apache.thrift.protocol.TType.I32, (short)1); + private static final org.apache.thrift.protocol.TField STRING_VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("stringValue", org.apache.thrift.protocol.TType.STRING, (short)2); + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + I32_VALUE((short)1, "i32Value"), + STRING_VALUE((short)2, "stringValue"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // I32_VALUE + return I32_VALUE; + case 2: // STRING_VALUE + return STRING_VALUE; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.I32_VALUE, new org.apache.thrift.meta_data.FieldMetaData("i32Value", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.STRING_VALUE, new org.apache.thrift.meta_data.FieldMetaData("stringValue", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TTypeQualifierValue.class, metaDataMap); + } + + public TTypeQualifierValue() { + super(); + } + + public TTypeQualifierValue(_Fields setField, Object value) { + super(setField, value); + } + + public TTypeQualifierValue(TTypeQualifierValue other) { + super(other); + } + public TTypeQualifierValue deepCopy() { + return new TTypeQualifierValue(this); + } + + public static TTypeQualifierValue i32Value(int value) { + TTypeQualifierValue x = new TTypeQualifierValue(); + x.setI32Value(value); + return x; + } + + public static TTypeQualifierValue stringValue(String value) { + TTypeQualifierValue x = new TTypeQualifierValue(); + x.setStringValue(value); + return x; + } + + + @Override + protected void checkType(_Fields setField, Object value) throws ClassCastException { + switch (setField) { + case I32_VALUE: + if (value instanceof Integer) { + break; + } + throw new ClassCastException("Was expecting value of type Integer for field 'i32Value', but got " + value.getClass().getSimpleName()); + case STRING_VALUE: + if (value instanceof String) { + break; + } + throw new ClassCastException("Was expecting value of type String for field 'stringValue', but got " + value.getClass().getSimpleName()); + default: + throw new IllegalArgumentException("Unknown field id " + setField); + } + } + + @Override + protected Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TField field) throws org.apache.thrift.TException { + _Fields setField = _Fields.findByThriftId(field.id); + if (setField != null) { + switch (setField) { + case I32_VALUE: + if (field.type == I32_VALUE_FIELD_DESC.type) { + Integer i32Value; + i32Value = iprot.readI32(); + return i32Value; + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + return null; + } + case STRING_VALUE: + if (field.type == STRING_VALUE_FIELD_DESC.type) { + String stringValue; + stringValue = iprot.readString(); + return stringValue; + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + return null; + } + default: + throw new IllegalStateException("setField wasn't null, but didn't match any of the case statements!"); + } + } else { + return null; + } + } + + @Override + protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + switch (setField_) { + case I32_VALUE: + Integer i32Value = (Integer)value_; + oprot.writeI32(i32Value); + return; + case STRING_VALUE: + String stringValue = (String)value_; + oprot.writeString(stringValue); + return; + default: + throw new IllegalStateException("Cannot write union with unknown field " + setField_); + } + } + + @Override + protected Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot, short fieldID) throws org.apache.thrift.TException { + _Fields setField = _Fields.findByThriftId(fieldID); + if (setField != null) { + switch (setField) { + case I32_VALUE: + Integer i32Value; + i32Value = iprot.readI32(); + return i32Value; + case STRING_VALUE: + String stringValue; + stringValue = iprot.readString(); + return stringValue; + default: + throw new IllegalStateException("setField wasn't null, but didn't match any of the case statements!"); + } + } else { + throw new TProtocolException("Couldn't find a field with field id " + fieldID); + } + } + + @Override + protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + switch (setField_) { + case I32_VALUE: + Integer i32Value = (Integer)value_; + oprot.writeI32(i32Value); + return; + case STRING_VALUE: + String stringValue = (String)value_; + oprot.writeString(stringValue); + return; + default: + throw new IllegalStateException("Cannot write union with unknown field " + setField_); + } + } + + @Override + protected org.apache.thrift.protocol.TField getFieldDesc(_Fields setField) { + switch (setField) { + case I32_VALUE: + return I32_VALUE_FIELD_DESC; + case STRING_VALUE: + return STRING_VALUE_FIELD_DESC; + default: + throw new IllegalArgumentException("Unknown field id " + setField); + } + } + + @Override + protected org.apache.thrift.protocol.TStruct getStructDesc() { + return STRUCT_DESC; + } + + @Override + protected _Fields enumForId(short id) { + return _Fields.findByThriftIdOrThrow(id); + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + + public int getI32Value() { + if (getSetField() == _Fields.I32_VALUE) { + return (Integer)getFieldValue(); + } else { + throw new RuntimeException("Cannot get field 'i32Value' because union is currently set to " + getFieldDesc(getSetField()).name); + } + } + + public void setI32Value(int value) { + setField_ = _Fields.I32_VALUE; + value_ = value; + } + + public String getStringValue() { + if (getSetField() == _Fields.STRING_VALUE) { + return (String)getFieldValue(); + } else { + throw new RuntimeException("Cannot get field 'stringValue' because union is currently set to " + getFieldDesc(getSetField()).name); + } + } + + public void setStringValue(String value) { + if (value == null) throw new NullPointerException(); + setField_ = _Fields.STRING_VALUE; + value_ = value; + } + + public boolean isSetI32Value() { + return setField_ == _Fields.I32_VALUE; + } + + + public boolean isSetStringValue() { + return setField_ == _Fields.STRING_VALUE; + } + + + public boolean equals(Object other) { + if (other instanceof TTypeQualifierValue) { + return equals((TTypeQualifierValue)other); + } else { + return false; + } + } + + public boolean equals(TTypeQualifierValue other) { + return other != null && getSetField() == other.getSetField() && getFieldValue().equals(other.getFieldValue()); + } + + @Override + public int compareTo(TTypeQualifierValue other) { + int lastComparison = org.apache.thrift.TBaseHelper.compareTo(getSetField(), other.getSetField()); + if (lastComparison == 0) { + return org.apache.thrift.TBaseHelper.compareTo(getFieldValue(), other.getFieldValue()); + } + return lastComparison; + } + + + @Override + public int hashCode() { + HashCodeBuilder hcb = new HashCodeBuilder(); + hcb.append(this.getClass().getName()); + org.apache.thrift.TFieldIdEnum setField = getSetField(); + if (setField != null) { + hcb.append(setField.getThriftFieldId()); + Object value = getFieldValue(); + if (value instanceof org.apache.thrift.TEnum) { + hcb.append(((org.apache.thrift.TEnum)getFieldValue()).getValue()); + } else { + hcb.append(value); + } + } + return hcb.toHashCode(); + } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + +} diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeQualifiers.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeQualifiers.java new file mode 100644 index 0000000..3935555 --- /dev/null +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TTypeQualifiers.java @@ -0,0 +1,450 @@ +/** + * Autogenerated by Thrift Compiler (0.9.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hive.service.cli.thrift; + +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class TTypeQualifiers implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTypeQualifiers"); + + private static final org.apache.thrift.protocol.TField QUALIFIERS_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifiers", org.apache.thrift.protocol.TType.MAP, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new TTypeQualifiersStandardSchemeFactory()); + schemes.put(TupleScheme.class, new TTypeQualifiersTupleSchemeFactory()); + } + + private Map qualifiers; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + QUALIFIERS((short)1, "qualifiers"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // QUALIFIERS + return QUALIFIERS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.QUALIFIERS, new org.apache.thrift.meta_data.FieldMetaData("qualifiers", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTypeQualifierValue.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TTypeQualifiers.class, metaDataMap); + } + + public TTypeQualifiers() { + } + + public TTypeQualifiers( + Map qualifiers) + { + this(); + this.qualifiers = qualifiers; + } + + /** + * Performs a deep copy on other. + */ + public TTypeQualifiers(TTypeQualifiers other) { + if (other.isSetQualifiers()) { + Map __this__qualifiers = new HashMap(); + for (Map.Entry other_element : other.qualifiers.entrySet()) { + + String other_element_key = other_element.getKey(); + TTypeQualifierValue other_element_value = other_element.getValue(); + + String __this__qualifiers_copy_key = other_element_key; + + TTypeQualifierValue __this__qualifiers_copy_value = new TTypeQualifierValue(other_element_value); + + __this__qualifiers.put(__this__qualifiers_copy_key, __this__qualifiers_copy_value); + } + this.qualifiers = __this__qualifiers; + } + } + + public TTypeQualifiers deepCopy() { + return new TTypeQualifiers(this); + } + + @Override + public void clear() { + this.qualifiers = null; + } + + public int getQualifiersSize() { + return (this.qualifiers == null) ? 0 : this.qualifiers.size(); + } + + public void putToQualifiers(String key, TTypeQualifierValue val) { + if (this.qualifiers == null) { + this.qualifiers = new HashMap(); + } + this.qualifiers.put(key, val); + } + + public Map getQualifiers() { + return this.qualifiers; + } + + public void setQualifiers(Map qualifiers) { + this.qualifiers = qualifiers; + } + + public void unsetQualifiers() { + this.qualifiers = null; + } + + /** Returns true if field qualifiers is set (has been assigned a value) and false otherwise */ + public boolean isSetQualifiers() { + return this.qualifiers != null; + } + + public void setQualifiersIsSet(boolean value) { + if (!value) { + this.qualifiers = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case QUALIFIERS: + if (value == null) { + unsetQualifiers(); + } else { + setQualifiers((Map)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case QUALIFIERS: + return getQualifiers(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case QUALIFIERS: + return isSetQualifiers(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof TTypeQualifiers) + return this.equals((TTypeQualifiers)that); + return false; + } + + public boolean equals(TTypeQualifiers that) { + if (that == null) + return false; + + boolean this_present_qualifiers = true && this.isSetQualifiers(); + boolean that_present_qualifiers = true && that.isSetQualifiers(); + if (this_present_qualifiers || that_present_qualifiers) { + if (!(this_present_qualifiers && that_present_qualifiers)) + return false; + if (!this.qualifiers.equals(that.qualifiers)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_qualifiers = true && (isSetQualifiers()); + builder.append(present_qualifiers); + if (present_qualifiers) + builder.append(qualifiers); + + return builder.toHashCode(); + } + + public int compareTo(TTypeQualifiers other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + TTypeQualifiers typedOther = (TTypeQualifiers)other; + + lastComparison = Boolean.valueOf(isSetQualifiers()).compareTo(typedOther.isSetQualifiers()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetQualifiers()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifiers, typedOther.qualifiers); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("TTypeQualifiers("); + boolean first = true; + + sb.append("qualifiers:"); + if (this.qualifiers == null) { + sb.append("null"); + } else { + sb.append(this.qualifiers); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetQualifiers()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifiers' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class TTypeQualifiersStandardSchemeFactory implements SchemeFactory { + public TTypeQualifiersStandardScheme getScheme() { + return new TTypeQualifiersStandardScheme(); + } + } + + private static class TTypeQualifiersStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, TTypeQualifiers struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // QUALIFIERS + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map0 = iprot.readMapBegin(); + struct.qualifiers = new HashMap(2*_map0.size); + for (int _i1 = 0; _i1 < _map0.size; ++_i1) + { + String _key2; // required + TTypeQualifierValue _val3; // required + _key2 = iprot.readString(); + _val3 = new TTypeQualifierValue(); + _val3.read(iprot); + struct.qualifiers.put(_key2, _val3); + } + iprot.readMapEnd(); + } + struct.setQualifiersIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, TTypeQualifiers struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.qualifiers != null) { + oprot.writeFieldBegin(QUALIFIERS_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.qualifiers.size())); + for (Map.Entry _iter4 : struct.qualifiers.entrySet()) + { + oprot.writeString(_iter4.getKey()); + _iter4.getValue().write(oprot); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class TTypeQualifiersTupleSchemeFactory implements SchemeFactory { + public TTypeQualifiersTupleScheme getScheme() { + return new TTypeQualifiersTupleScheme(); + } + } + + private static class TTypeQualifiersTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, TTypeQualifiers struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + { + oprot.writeI32(struct.qualifiers.size()); + for (Map.Entry _iter5 : struct.qualifiers.entrySet()) + { + oprot.writeString(_iter5.getKey()); + _iter5.getValue().write(oprot); + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, TTypeQualifiers struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + { + org.apache.thrift.protocol.TMap _map6 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.qualifiers = new HashMap(2*_map6.size); + for (int _i7 = 0; _i7 < _map6.size; ++_i7) + { + String _key8; // required + TTypeQualifierValue _val9; // required + _key8 = iprot.readString(); + _val9 = new TTypeQualifierValue(); + _val9.read(iprot); + struct.qualifiers.put(_key8, _val9); + } + } + struct.setQualifiersIsSet(true); + } + } + +} + diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TUnionTypeEntry.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TUnionTypeEntry.java index 9254547..73dd45d 100644 --- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TUnionTypeEntry.java +++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TUnionTypeEntry.java @@ -355,15 +355,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TUnionTypeEntry str case 1: // NAME_TO_TYPE_PTR if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map10 = iprot.readMapBegin(); - struct.nameToTypePtr = new HashMap(2*_map10.size); - for (int _i11 = 0; _i11 < _map10.size; ++_i11) + org.apache.thrift.protocol.TMap _map20 = iprot.readMapBegin(); + struct.nameToTypePtr = new HashMap(2*_map20.size); + for (int _i21 = 0; _i21 < _map20.size; ++_i21) { - String _key12; // required - int _val13; // required - _key12 = iprot.readString(); - _val13 = iprot.readI32(); - struct.nameToTypePtr.put(_key12, _val13); + String _key22; // required + int _val23; // required + _key22 = iprot.readString(); + _val23 = iprot.readI32(); + struct.nameToTypePtr.put(_key22, _val23); } iprot.readMapEnd(); } @@ -389,10 +389,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TUnionTypeEntry st oprot.writeFieldBegin(NAME_TO_TYPE_PTR_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, struct.nameToTypePtr.size())); - for (Map.Entry _iter14 : struct.nameToTypePtr.entrySet()) + for (Map.Entry _iter24 : struct.nameToTypePtr.entrySet()) { - oprot.writeString(_iter14.getKey()); - oprot.writeI32(_iter14.getValue()); + oprot.writeString(_iter24.getKey()); + oprot.writeI32(_iter24.getValue()); } oprot.writeMapEnd(); } @@ -417,10 +417,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TUnionTypeEntry str TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.nameToTypePtr.size()); - for (Map.Entry _iter15 : struct.nameToTypePtr.entrySet()) + for (Map.Entry _iter25 : struct.nameToTypePtr.entrySet()) { - oprot.writeString(_iter15.getKey()); - oprot.writeI32(_iter15.getValue()); + oprot.writeString(_iter25.getKey()); + oprot.writeI32(_iter25.getValue()); } } } @@ -429,15 +429,15 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TUnionTypeEntry str public void read(org.apache.thrift.protocol.TProtocol prot, TUnionTypeEntry struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TMap _map16 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.nameToTypePtr = new HashMap(2*_map16.size); - for (int _i17 = 0; _i17 < _map16.size; ++_i17) + org.apache.thrift.protocol.TMap _map26 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.nameToTypePtr = new HashMap(2*_map26.size); + for (int _i27 = 0; _i27 < _map26.size; ++_i27) { - String _key18; // required - int _val19; // required - _key18 = iprot.readString(); - _val19 = iprot.readI32(); - struct.nameToTypePtr.put(_key18, _val19); + String _key28; // required + int _val29; // required + _key28 = iprot.readString(); + _val29 = iprot.readI32(); + struct.nameToTypePtr.put(_key28, _val29); } } struct.setNameToTypePtrIsSet(true); diff --git service/src/gen/thrift/gen-py/TCLIService/TCLIService-remote service/src/gen/thrift/gen-py/TCLIService/TCLIService-remote old mode 100644 new mode 100755 diff --git service/src/gen/thrift/gen-py/TCLIService/constants.py service/src/gen/thrift/gen-py/TCLIService/constants.py index a81196b..589ce88 100644 --- service/src/gen/thrift/gen-py/TCLIService/constants.py +++ service/src/gen/thrift/gen-py/TCLIService/constants.py @@ -23,6 +23,7 @@ 15, 16, 17, + 18, ]) COMPLEX_TYPES = set([ 10, @@ -53,4 +54,6 @@ 15 : "DECIMAL", 16 : "NULL", 17 : "DATE", + 18 : "VARCHAR", } +CHARACTER_MAXIMUM_LENGTH = "characterMaximumLength" diff --git service/src/gen/thrift/gen-py/TCLIService/ttypes.py service/src/gen/thrift/gen-py/TCLIService/ttypes.py index e6de812..b286b05 100644 --- service/src/gen/thrift/gen-py/TCLIService/ttypes.py +++ service/src/gen/thrift/gen-py/TCLIService/ttypes.py @@ -19,15 +19,18 @@ class TProtocolVersion: HIVE_CLI_SERVICE_PROTOCOL_V1 = 0 HIVE_CLI_SERVICE_PROTOCOL_V2 = 1 + HIVE_CLI_SERVICE_PROTOCOL_V3 = 2 _VALUES_TO_NAMES = { 0: "HIVE_CLI_SERVICE_PROTOCOL_V1", 1: "HIVE_CLI_SERVICE_PROTOCOL_V2", + 2: "HIVE_CLI_SERVICE_PROTOCOL_V3", } _NAMES_TO_VALUES = { "HIVE_CLI_SERVICE_PROTOCOL_V1": 0, "HIVE_CLI_SERVICE_PROTOCOL_V2": 1, + "HIVE_CLI_SERVICE_PROTOCOL_V3": 2, } class TTypeId: @@ -49,6 +52,7 @@ class TTypeId: DECIMAL_TYPE = 15 NULL_TYPE = 16 DATE_TYPE = 17 + VARCHAR_TYPE = 18 _VALUES_TO_NAMES = { 0: "BOOLEAN_TYPE", @@ -69,6 +73,7 @@ class TTypeId: 15: "DECIMAL_TYPE", 16: "NULL_TYPE", 17: "DATE_TYPE", + 18: "VARCHAR_TYPE", } _NAMES_TO_VALUES = { @@ -90,6 +95,7 @@ class TTypeId: "DECIMAL_TYPE": 15, "NULL_TYPE": 16, "DATE_TYPE": 17, + "VARCHAR_TYPE": 18, } class TStatusCode: @@ -358,19 +364,167 @@ class TFetchOrientation: } +class TTypeQualifierValue: + """ + Attributes: + - i32Value + - stringValue + """ + + thrift_spec = ( + None, # 0 + (1, TType.I32, 'i32Value', None, None, ), # 1 + (2, TType.STRING, 'stringValue', None, None, ), # 2 + ) + + def __init__(self, i32Value=None, stringValue=None,): + self.i32Value = i32Value + self.stringValue = stringValue + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.I32: + self.i32Value = iprot.readI32(); + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.stringValue = iprot.readString(); + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('TTypeQualifierValue') + if self.i32Value is not None: + oprot.writeFieldBegin('i32Value', TType.I32, 1) + oprot.writeI32(self.i32Value) + oprot.writeFieldEnd() + if self.stringValue is not None: + oprot.writeFieldBegin('stringValue', TType.STRING, 2) + oprot.writeString(self.stringValue) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class TTypeQualifiers: + """ + Attributes: + - qualifiers + """ + + thrift_spec = ( + None, # 0 + (1, TType.MAP, 'qualifiers', (TType.STRING,None,TType.STRUCT,(TTypeQualifierValue, TTypeQualifierValue.thrift_spec)), None, ), # 1 + ) + + def __init__(self, qualifiers=None,): + self.qualifiers = qualifiers + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.MAP: + self.qualifiers = {} + (_ktype1, _vtype2, _size0 ) = iprot.readMapBegin() + for _i4 in xrange(_size0): + _key5 = iprot.readString(); + _val6 = TTypeQualifierValue() + _val6.read(iprot) + self.qualifiers[_key5] = _val6 + iprot.readMapEnd() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('TTypeQualifiers') + if self.qualifiers is not None: + oprot.writeFieldBegin('qualifiers', TType.MAP, 1) + oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.qualifiers)) + for kiter7,viter8 in self.qualifiers.items(): + oprot.writeString(kiter7) + viter8.write(oprot) + oprot.writeMapEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + if self.qualifiers is None: + raise TProtocol.TProtocolException(message='Required field qualifiers is unset!') + return + + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class TPrimitiveTypeEntry: """ Attributes: - type + - typeQualifiers """ thrift_spec = ( None, # 0 (1, TType.I32, 'type', None, None, ), # 1 + (2, TType.STRUCT, 'typeQualifiers', (TTypeQualifiers, TTypeQualifiers.thrift_spec), None, ), # 2 ) - def __init__(self, type=None,): + def __init__(self, type=None, typeQualifiers=None,): self.type = type + self.typeQualifiers = typeQualifiers def read(self, iprot): if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: @@ -386,6 +540,12 @@ def read(self, iprot): self.type = iprot.readI32(); else: iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.typeQualifiers = TTypeQualifiers() + self.typeQualifiers.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -400,6 +560,10 @@ def write(self, oprot): oprot.writeFieldBegin('type', TType.I32, 1) oprot.writeI32(self.type) oprot.writeFieldEnd() + if self.typeQualifiers is not None: + oprot.writeFieldBegin('typeQualifiers', TType.STRUCT, 2) + self.typeQualifiers.write(oprot) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -584,11 +748,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.nameToTypePtr = {} - (_ktype1, _vtype2, _size0 ) = iprot.readMapBegin() - for _i4 in xrange(_size0): - _key5 = iprot.readString(); - _val6 = iprot.readI32(); - self.nameToTypePtr[_key5] = _val6 + (_ktype10, _vtype11, _size9 ) = iprot.readMapBegin() + for _i13 in xrange(_size9): + _key14 = iprot.readString(); + _val15 = iprot.readI32(); + self.nameToTypePtr[_key14] = _val15 iprot.readMapEnd() else: iprot.skip(ftype) @@ -605,9 +769,9 @@ def write(self, oprot): if self.nameToTypePtr is not None: oprot.writeFieldBegin('nameToTypePtr', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.I32, len(self.nameToTypePtr)) - for kiter7,viter8 in self.nameToTypePtr.items(): - oprot.writeString(kiter7) - oprot.writeI32(viter8) + for kiter16,viter17 in self.nameToTypePtr.items(): + oprot.writeString(kiter16) + oprot.writeI32(viter17) oprot.writeMapEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -656,11 +820,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.nameToTypePtr = {} - (_ktype10, _vtype11, _size9 ) = iprot.readMapBegin() - for _i13 in xrange(_size9): - _key14 = iprot.readString(); - _val15 = iprot.readI32(); - self.nameToTypePtr[_key14] = _val15 + (_ktype19, _vtype20, _size18 ) = iprot.readMapBegin() + for _i22 in xrange(_size18): + _key23 = iprot.readString(); + _val24 = iprot.readI32(); + self.nameToTypePtr[_key23] = _val24 iprot.readMapEnd() else: iprot.skip(ftype) @@ -677,9 +841,9 @@ def write(self, oprot): if self.nameToTypePtr is not None: oprot.writeFieldBegin('nameToTypePtr', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.I32, len(self.nameToTypePtr)) - for kiter16,viter17 in self.nameToTypePtr.items(): - oprot.writeString(kiter16) - oprot.writeI32(viter17) + for kiter25,viter26 in self.nameToTypePtr.items(): + oprot.writeString(kiter25) + oprot.writeI32(viter26) oprot.writeMapEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -916,11 +1080,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.types = [] - (_etype21, _size18) = iprot.readListBegin() - for _i22 in xrange(_size18): - _elem23 = TTypeEntry() - _elem23.read(iprot) - self.types.append(_elem23) + (_etype30, _size27) = iprot.readListBegin() + for _i31 in xrange(_size27): + _elem32 = TTypeEntry() + _elem32.read(iprot) + self.types.append(_elem32) iprot.readListEnd() else: iprot.skip(ftype) @@ -937,8 +1101,8 @@ def write(self, oprot): if self.types is not None: oprot.writeFieldBegin('types', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.types)) - for iter24 in self.types: - iter24.write(oprot) + for iter33 in self.types: + iter33.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -1090,11 +1254,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.columns = [] - (_etype28, _size25) = iprot.readListBegin() - for _i29 in xrange(_size25): - _elem30 = TColumnDesc() - _elem30.read(iprot) - self.columns.append(_elem30) + (_etype37, _size34) = iprot.readListBegin() + for _i38 in xrange(_size34): + _elem39 = TColumnDesc() + _elem39.read(iprot) + self.columns.append(_elem39) iprot.readListEnd() else: iprot.skip(ftype) @@ -1111,8 +1275,8 @@ def write(self, oprot): if self.columns is not None: oprot.writeFieldBegin('columns', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.columns)) - for iter31 in self.columns: - iter31.write(oprot) + for iter40 in self.columns: + iter40.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -1599,77 +1763,77 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.boolColumn = [] - (_etype35, _size32) = iprot.readListBegin() - for _i36 in xrange(_size32): - _elem37 = TBoolValue() - _elem37.read(iprot) - self.boolColumn.append(_elem37) + (_etype44, _size41) = iprot.readListBegin() + for _i45 in xrange(_size41): + _elem46 = TBoolValue() + _elem46.read(iprot) + self.boolColumn.append(_elem46) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 2: if ftype == TType.LIST: self.byteColumn = [] - (_etype41, _size38) = iprot.readListBegin() - for _i42 in xrange(_size38): - _elem43 = TByteValue() - _elem43.read(iprot) - self.byteColumn.append(_elem43) + (_etype50, _size47) = iprot.readListBegin() + for _i51 in xrange(_size47): + _elem52 = TByteValue() + _elem52.read(iprot) + self.byteColumn.append(_elem52) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.i16Column = [] - (_etype47, _size44) = iprot.readListBegin() - for _i48 in xrange(_size44): - _elem49 = TI16Value() - _elem49.read(iprot) - self.i16Column.append(_elem49) + (_etype56, _size53) = iprot.readListBegin() + for _i57 in xrange(_size53): + _elem58 = TI16Value() + _elem58.read(iprot) + self.i16Column.append(_elem58) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: if ftype == TType.LIST: self.i32Column = [] - (_etype53, _size50) = iprot.readListBegin() - for _i54 in xrange(_size50): - _elem55 = TI32Value() - _elem55.read(iprot) - self.i32Column.append(_elem55) + (_etype62, _size59) = iprot.readListBegin() + for _i63 in xrange(_size59): + _elem64 = TI32Value() + _elem64.read(iprot) + self.i32Column.append(_elem64) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 5: if ftype == TType.LIST: self.i64Column = [] - (_etype59, _size56) = iprot.readListBegin() - for _i60 in xrange(_size56): - _elem61 = TI64Value() - _elem61.read(iprot) - self.i64Column.append(_elem61) + (_etype68, _size65) = iprot.readListBegin() + for _i69 in xrange(_size65): + _elem70 = TI64Value() + _elem70.read(iprot) + self.i64Column.append(_elem70) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 6: if ftype == TType.LIST: self.doubleColumn = [] - (_etype65, _size62) = iprot.readListBegin() - for _i66 in xrange(_size62): - _elem67 = TDoubleValue() - _elem67.read(iprot) - self.doubleColumn.append(_elem67) + (_etype74, _size71) = iprot.readListBegin() + for _i75 in xrange(_size71): + _elem76 = TDoubleValue() + _elem76.read(iprot) + self.doubleColumn.append(_elem76) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 7: if ftype == TType.LIST: self.stringColumn = [] - (_etype71, _size68) = iprot.readListBegin() - for _i72 in xrange(_size68): - _elem73 = TStringValue() - _elem73.read(iprot) - self.stringColumn.append(_elem73) + (_etype80, _size77) = iprot.readListBegin() + for _i81 in xrange(_size77): + _elem82 = TStringValue() + _elem82.read(iprot) + self.stringColumn.append(_elem82) iprot.readListEnd() else: iprot.skip(ftype) @@ -1686,50 +1850,50 @@ def write(self, oprot): if self.boolColumn is not None: oprot.writeFieldBegin('boolColumn', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.boolColumn)) - for iter74 in self.boolColumn: - iter74.write(oprot) + for iter83 in self.boolColumn: + iter83.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.byteColumn is not None: oprot.writeFieldBegin('byteColumn', TType.LIST, 2) oprot.writeListBegin(TType.STRUCT, len(self.byteColumn)) - for iter75 in self.byteColumn: - iter75.write(oprot) + for iter84 in self.byteColumn: + iter84.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.i16Column is not None: oprot.writeFieldBegin('i16Column', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.i16Column)) - for iter76 in self.i16Column: - iter76.write(oprot) + for iter85 in self.i16Column: + iter85.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.i32Column is not None: oprot.writeFieldBegin('i32Column', TType.LIST, 4) oprot.writeListBegin(TType.STRUCT, len(self.i32Column)) - for iter77 in self.i32Column: - iter77.write(oprot) + for iter86 in self.i32Column: + iter86.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.i64Column is not None: oprot.writeFieldBegin('i64Column', TType.LIST, 5) oprot.writeListBegin(TType.STRUCT, len(self.i64Column)) - for iter78 in self.i64Column: - iter78.write(oprot) + for iter87 in self.i64Column: + iter87.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.doubleColumn is not None: oprot.writeFieldBegin('doubleColumn', TType.LIST, 6) oprot.writeListBegin(TType.STRUCT, len(self.doubleColumn)) - for iter79 in self.doubleColumn: - iter79.write(oprot) + for iter88 in self.doubleColumn: + iter88.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.stringColumn is not None: oprot.writeFieldBegin('stringColumn', TType.LIST, 7) oprot.writeListBegin(TType.STRUCT, len(self.stringColumn)) - for iter80 in self.stringColumn: - iter80.write(oprot) + for iter89 in self.stringColumn: + iter89.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -1915,11 +2079,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.colVals = [] - (_etype84, _size81) = iprot.readListBegin() - for _i85 in xrange(_size81): - _elem86 = TColumnValue() - _elem86.read(iprot) - self.colVals.append(_elem86) + (_etype93, _size90) = iprot.readListBegin() + for _i94 in xrange(_size90): + _elem95 = TColumnValue() + _elem95.read(iprot) + self.colVals.append(_elem95) iprot.readListEnd() else: iprot.skip(ftype) @@ -1936,8 +2100,8 @@ def write(self, oprot): if self.colVals is not None: oprot.writeFieldBegin('colVals', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.colVals)) - for iter87 in self.colVals: - iter87.write(oprot) + for iter96 in self.colVals: + iter96.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -1997,22 +2161,22 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.rows = [] - (_etype91, _size88) = iprot.readListBegin() - for _i92 in xrange(_size88): - _elem93 = TRow() - _elem93.read(iprot) - self.rows.append(_elem93) + (_etype100, _size97) = iprot.readListBegin() + for _i101 in xrange(_size97): + _elem102 = TRow() + _elem102.read(iprot) + self.rows.append(_elem102) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.columns = [] - (_etype97, _size94) = iprot.readListBegin() - for _i98 in xrange(_size94): - _elem99 = TColumn() - _elem99.read(iprot) - self.columns.append(_elem99) + (_etype106, _size103) = iprot.readListBegin() + for _i107 in xrange(_size103): + _elem108 = TColumn() + _elem108.read(iprot) + self.columns.append(_elem108) iprot.readListEnd() else: iprot.skip(ftype) @@ -2033,15 +2197,15 @@ def write(self, oprot): if self.rows is not None: oprot.writeFieldBegin('rows', TType.LIST, 2) oprot.writeListBegin(TType.STRUCT, len(self.rows)) - for iter100 in self.rows: - iter100.write(oprot) + for iter109 in self.rows: + iter109.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.columns is not None: oprot.writeFieldBegin('columns', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.columns)) - for iter101 in self.columns: - iter101.write(oprot) + for iter110 in self.columns: + iter110.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -2109,10 +2273,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.infoMessages = [] - (_etype105, _size102) = iprot.readListBegin() - for _i106 in xrange(_size102): - _elem107 = iprot.readString(); - self.infoMessages.append(_elem107) + (_etype114, _size111) = iprot.readListBegin() + for _i115 in xrange(_size111): + _elem116 = iprot.readString(); + self.infoMessages.append(_elem116) iprot.readListEnd() else: iprot.skip(ftype) @@ -2148,8 +2312,8 @@ def write(self, oprot): if self.infoMessages is not None: oprot.writeFieldBegin('infoMessages', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.infoMessages)) - for iter108 in self.infoMessages: - oprot.writeString(iter108) + for iter117 in self.infoMessages: + oprot.writeString(iter117) oprot.writeListEnd() oprot.writeFieldEnd() if self.sqlState is not None: @@ -2437,7 +2601,7 @@ class TOpenSessionReq: thrift_spec = ( None, # 0 - (1, TType.I32, 'client_protocol', None, 1, ), # 1 + (1, TType.I32, 'client_protocol', None, 2, ), # 1 (2, TType.STRING, 'username', None, None, ), # 2 (3, TType.STRING, 'password', None, None, ), # 3 (4, TType.MAP, 'configuration', (TType.STRING,None,TType.STRING,None), None, ), # 4 @@ -2476,11 +2640,11 @@ def read(self, iprot): elif fid == 4: if ftype == TType.MAP: self.configuration = {} - (_ktype110, _vtype111, _size109 ) = iprot.readMapBegin() - for _i113 in xrange(_size109): - _key114 = iprot.readString(); - _val115 = iprot.readString(); - self.configuration[_key114] = _val115 + (_ktype119, _vtype120, _size118 ) = iprot.readMapBegin() + for _i122 in xrange(_size118): + _key123 = iprot.readString(); + _val124 = iprot.readString(); + self.configuration[_key123] = _val124 iprot.readMapEnd() else: iprot.skip(ftype) @@ -2509,9 +2673,9 @@ def write(self, oprot): if self.configuration is not None: oprot.writeFieldBegin('configuration', TType.MAP, 4) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.configuration)) - for kiter116,viter117 in self.configuration.items(): - oprot.writeString(kiter116) - oprot.writeString(viter117) + for kiter125,viter126 in self.configuration.items(): + oprot.writeString(kiter125) + oprot.writeString(viter126) oprot.writeMapEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -2546,7 +2710,7 @@ class TOpenSessionResp: thrift_spec = ( None, # 0 (1, TType.STRUCT, 'status', (TStatus, TStatus.thrift_spec), None, ), # 1 - (2, TType.I32, 'serverProtocolVersion', None, 1, ), # 2 + (2, TType.I32, 'serverProtocolVersion', None, 2, ), # 2 (3, TType.STRUCT, 'sessionHandle', (TSessionHandle, TSessionHandle.thrift_spec), None, ), # 3 (4, TType.MAP, 'configuration', (TType.STRING,None,TType.STRING,None), None, ), # 4 ) @@ -2586,11 +2750,11 @@ def read(self, iprot): elif fid == 4: if ftype == TType.MAP: self.configuration = {} - (_ktype119, _vtype120, _size118 ) = iprot.readMapBegin() - for _i122 in xrange(_size118): - _key123 = iprot.readString(); - _val124 = iprot.readString(); - self.configuration[_key123] = _val124 + (_ktype128, _vtype129, _size127 ) = iprot.readMapBegin() + for _i131 in xrange(_size127): + _key132 = iprot.readString(); + _val133 = iprot.readString(); + self.configuration[_key132] = _val133 iprot.readMapEnd() else: iprot.skip(ftype) @@ -2619,9 +2783,9 @@ def write(self, oprot): if self.configuration is not None: oprot.writeFieldBegin('configuration', TType.MAP, 4) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.configuration)) - for kiter125,viter126 in self.configuration.items(): - oprot.writeString(kiter125) - oprot.writeString(viter126) + for kiter134,viter135 in self.configuration.items(): + oprot.writeString(kiter134) + oprot.writeString(viter135) oprot.writeMapEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -3093,11 +3257,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.confOverlay = {} - (_ktype128, _vtype129, _size127 ) = iprot.readMapBegin() - for _i131 in xrange(_size127): - _key132 = iprot.readString(); - _val133 = iprot.readString(); - self.confOverlay[_key132] = _val133 + (_ktype137, _vtype138, _size136 ) = iprot.readMapBegin() + for _i140 in xrange(_size136): + _key141 = iprot.readString(); + _val142 = iprot.readString(); + self.confOverlay[_key141] = _val142 iprot.readMapEnd() else: iprot.skip(ftype) @@ -3127,9 +3291,9 @@ def write(self, oprot): if self.confOverlay is not None: oprot.writeFieldBegin('confOverlay', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.confOverlay)) - for kiter134,viter135 in self.confOverlay.items(): - oprot.writeString(kiter134) - oprot.writeString(viter135) + for kiter143,viter144 in self.confOverlay.items(): + oprot.writeString(kiter143) + oprot.writeString(viter144) oprot.writeMapEnd() oprot.writeFieldEnd() if self.runAsync is not None: @@ -3734,10 +3898,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.tableTypes = [] - (_etype139, _size136) = iprot.readListBegin() - for _i140 in xrange(_size136): - _elem141 = iprot.readString(); - self.tableTypes.append(_elem141) + (_etype148, _size145) = iprot.readListBegin() + for _i149 in xrange(_size145): + _elem150 = iprot.readString(); + self.tableTypes.append(_elem150) iprot.readListEnd() else: iprot.skip(ftype) @@ -3770,8 +3934,8 @@ def write(self, oprot): if self.tableTypes is not None: oprot.writeFieldBegin('tableTypes', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.tableTypes)) - for iter142 in self.tableTypes: - oprot.writeString(iter142) + for iter151 in self.tableTypes: + oprot.writeString(iter151) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() diff --git service/src/gen/thrift/gen-py/hive_service/ThriftHive-remote service/src/gen/thrift/gen-py/hive_service/ThriftHive-remote old mode 100644 new mode 100755 diff --git service/src/gen/thrift/gen-rb/t_c_l_i_service_constants.rb service/src/gen/thrift/gen-rb/t_c_l_i_service_constants.rb index f576689..8c341c8 100644 --- service/src/gen/thrift/gen-rb/t_c_l_i_service_constants.rb +++ service/src/gen/thrift/gen-rb/t_c_l_i_service_constants.rb @@ -21,6 +21,7 @@ PRIMITIVE_TYPES = Set.new([ 15, 16, 17, + 18, ]) COMPLEX_TYPES = Set.new([ @@ -54,5 +55,8 @@ TYPE_NAMES = { 15 => %q"DECIMAL", 16 => %q"NULL", 17 => %q"DATE", + 18 => %q"VARCHAR", } +CHARACTER_MAXIMUM_LENGTH = %q"characterMaximumLength" + diff --git service/src/gen/thrift/gen-rb/t_c_l_i_service_types.rb service/src/gen/thrift/gen-rb/t_c_l_i_service_types.rb index 536dfa4..c608364 100644 --- service/src/gen/thrift/gen-rb/t_c_l_i_service_types.rb +++ service/src/gen/thrift/gen-rb/t_c_l_i_service_types.rb @@ -9,8 +9,9 @@ require 'thrift' module TProtocolVersion HIVE_CLI_SERVICE_PROTOCOL_V1 = 0 HIVE_CLI_SERVICE_PROTOCOL_V2 = 1 - VALUE_MAP = {0 => "HIVE_CLI_SERVICE_PROTOCOL_V1", 1 => "HIVE_CLI_SERVICE_PROTOCOL_V2"} - VALID_VALUES = Set.new([HIVE_CLI_SERVICE_PROTOCOL_V1, HIVE_CLI_SERVICE_PROTOCOL_V2]).freeze + HIVE_CLI_SERVICE_PROTOCOL_V3 = 2 + VALUE_MAP = {0 => "HIVE_CLI_SERVICE_PROTOCOL_V1", 1 => "HIVE_CLI_SERVICE_PROTOCOL_V2", 2 => "HIVE_CLI_SERVICE_PROTOCOL_V3"} + VALID_VALUES = Set.new([HIVE_CLI_SERVICE_PROTOCOL_V1, HIVE_CLI_SERVICE_PROTOCOL_V2, HIVE_CLI_SERVICE_PROTOCOL_V3]).freeze end module TTypeId @@ -32,8 +33,9 @@ module TTypeId DECIMAL_TYPE = 15 NULL_TYPE = 16 DATE_TYPE = 17 - VALUE_MAP = {0 => "BOOLEAN_TYPE", 1 => "TINYINT_TYPE", 2 => "SMALLINT_TYPE", 3 => "INT_TYPE", 4 => "BIGINT_TYPE", 5 => "FLOAT_TYPE", 6 => "DOUBLE_TYPE", 7 => "STRING_TYPE", 8 => "TIMESTAMP_TYPE", 9 => "BINARY_TYPE", 10 => "ARRAY_TYPE", 11 => "MAP_TYPE", 12 => "STRUCT_TYPE", 13 => "UNION_TYPE", 14 => "USER_DEFINED_TYPE", 15 => "DECIMAL_TYPE", 16 => "NULL_TYPE", 17 => "DATE_TYPE"} - VALID_VALUES = Set.new([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]).freeze + VARCHAR_TYPE = 18 + VALUE_MAP = {0 => "BOOLEAN_TYPE", 1 => "TINYINT_TYPE", 2 => "SMALLINT_TYPE", 3 => "INT_TYPE", 4 => "BIGINT_TYPE", 5 => "FLOAT_TYPE", 6 => "DOUBLE_TYPE", 7 => "STRING_TYPE", 8 => "TIMESTAMP_TYPE", 9 => "BINARY_TYPE", 10 => "ARRAY_TYPE", 11 => "MAP_TYPE", 12 => "STRUCT_TYPE", 13 => "UNION_TYPE", 14 => "USER_DEFINED_TYPE", 15 => "DECIMAL_TYPE", 16 => "NULL_TYPE", 17 => "DATE_TYPE", 18 => "VARCHAR_TYPE"} + VALID_VALUES = Set.new([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]).freeze end module TStatusCode @@ -136,12 +138,60 @@ module TFetchOrientation VALID_VALUES = Set.new([FETCH_NEXT, FETCH_PRIOR, FETCH_RELATIVE, FETCH_ABSOLUTE, FETCH_FIRST, FETCH_LAST]).freeze end +class TTypeQualifierValue < ::Thrift::Union + include ::Thrift::Struct_Union + class << self + def i32Value(val) + TTypeQualifierValue.new(:i32Value, val) + end + + def stringValue(val) + TTypeQualifierValue.new(:stringValue, val) + end + end + + I32VALUE = 1 + STRINGVALUE = 2 + + FIELDS = { + I32VALUE => {:type => ::Thrift::Types::I32, :name => 'i32Value', :optional => true}, + STRINGVALUE => {:type => ::Thrift::Types::STRING, :name => 'stringValue', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + raise(StandardError, 'Union fields are not set.') if get_set_field.nil? || get_value.nil? + end + + ::Thrift::Union.generate_accessors self +end + +class TTypeQualifiers + include ::Thrift::Struct, ::Thrift::Struct_Union + QUALIFIERS = 1 + + FIELDS = { + QUALIFIERS => {:type => ::Thrift::Types::MAP, :name => 'qualifiers', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRUCT, :class => ::TTypeQualifierValue}} + } + + def struct_fields; FIELDS; end + + def validate + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field qualifiers is unset!') unless @qualifiers + end + + ::Thrift::Struct.generate_accessors self +end + class TPrimitiveTypeEntry include ::Thrift::Struct, ::Thrift::Struct_Union TYPE = 1 + TYPEQUALIFIERS = 2 FIELDS = { - TYPE => {:type => ::Thrift::Types::I32, :name => 'type', :enum_class => ::TTypeId} + TYPE => {:type => ::Thrift::Types::I32, :name => 'type', :enum_class => ::TTypeId}, + TYPEQUALIFIERS => {:type => ::Thrift::Types::STRUCT, :name => 'typeQualifiers', :class => ::TTypeQualifiers, :optional => true} } def struct_fields; FIELDS; end @@ -726,7 +776,7 @@ class TOpenSessionReq CONFIGURATION = 4 FIELDS = { - CLIENT_PROTOCOL => {:type => ::Thrift::Types::I32, :name => 'client_protocol', :default => 1, :enum_class => ::TProtocolVersion}, + CLIENT_PROTOCOL => {:type => ::Thrift::Types::I32, :name => 'client_protocol', :default => 2, :enum_class => ::TProtocolVersion}, USERNAME => {:type => ::Thrift::Types::STRING, :name => 'username', :optional => true}, PASSWORD => {:type => ::Thrift::Types::STRING, :name => 'password', :optional => true}, CONFIGURATION => {:type => ::Thrift::Types::MAP, :name => 'configuration', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}, :optional => true} @@ -753,7 +803,7 @@ class TOpenSessionResp FIELDS = { STATUS => {:type => ::Thrift::Types::STRUCT, :name => 'status', :class => ::TStatus}, - SERVERPROTOCOLVERSION => {:type => ::Thrift::Types::I32, :name => 'serverProtocolVersion', :default => 1, :enum_class => ::TProtocolVersion}, + SERVERPROTOCOLVERSION => {:type => ::Thrift::Types::I32, :name => 'serverProtocolVersion', :default => 2, :enum_class => ::TProtocolVersion}, SESSIONHANDLE => {:type => ::Thrift::Types::STRUCT, :name => 'sessionHandle', :class => ::TSessionHandle, :optional => true}, CONFIGURATION => {:type => ::Thrift::Types::MAP, :name => 'configuration', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}, :optional => true} } diff --git service/src/java/org/apache/hive/service/cli/ColumnDescriptor.java service/src/java/org/apache/hive/service/cli/ColumnDescriptor.java index d702723..8324f95 100644 --- service/src/java/org/apache/hive/service/cli/ColumnDescriptor.java +++ service/src/java/org/apache/hive/service/cli/ColumnDescriptor.java @@ -50,11 +50,13 @@ public ColumnDescriptor(TColumnDesc tColumnDesc) { public ColumnDescriptor(FieldSchema column, int position) { name = column.getName(); comment = column.getComment(); - type = new TypeDescriptor(column.getType()); + type = new TypeDescriptor(column); this.position = position; } public static ColumnDescriptor newPrimitiveColumnDescriptor(String name, String comment, Type type, int position) { + // Current usage looks like it's only for metadata columns, but if that changes then + // this method may need to require a type qualifiers aruments. return new ColumnDescriptor(name, comment, new TypeDescriptor(type), position); } diff --git service/src/java/org/apache/hive/service/cli/ColumnValue.java service/src/java/org/apache/hive/service/cli/ColumnValue.java index 75b5407..905ba01 100644 --- service/src/java/org/apache/hive/service/cli/ColumnValue.java +++ service/src/java/org/apache/hive/service/cli/ColumnValue.java @@ -22,6 +22,7 @@ import java.sql.Timestamp; import org.apache.hadoop.hive.common.type.HiveDecimal; +import org.apache.hadoop.hive.common.type.HiveVarchar; import org.apache.hive.service.cli.thrift.TBoolValue; import org.apache.hive.service.cli.thrift.TByteValue; import org.apache.hive.service.cli.thrift.TColumnValue; @@ -118,6 +119,14 @@ public static ColumnValue stringValue(String value) { return new ColumnValue(TColumnValue.stringVal(tStringValue)); } + public static ColumnValue stringValue(HiveVarchar value) { + TStringValue tStringValue = new TStringValue(); + if (value != null) { + tStringValue.setValue(value.toString()); + } + return new ColumnValue(TColumnValue.stringVal(tStringValue)); + } + public static ColumnValue dateValue(Date value) { TStringValue tStringValue = new TStringValue(); if (value != null) { @@ -160,6 +169,8 @@ public static ColumnValue newColumnValue(Type type, Object value) { return doubleValue((Double)value); case STRING_TYPE: return stringValue((String)value); + case VARCHAR_TYPE: + return stringValue((HiveVarchar)value); case DATE_TYPE: return dateValue((Date)value); case TIMESTAMP_TYPE: diff --git service/src/java/org/apache/hive/service/cli/Type.java service/src/java/org/apache/hive/service/cli/Type.java index 3423262..f414fca 100644 --- service/src/java/org/apache/hive/service/cli/Type.java +++ service/src/java/org/apache/hive/service/cli/Type.java @@ -54,6 +54,10 @@ STRING_TYPE("STRING", java.sql.Types.VARCHAR, TTypeId.STRING_TYPE), + VARCHAR_TYPE("VARCHAR", + java.sql.Types.VARCHAR, + TTypeId.VARCHAR_TYPE, + true, false, false), DATE_TYPE("DATE", java.sql.Types.DATE, TTypeId.DATE_TYPE), @@ -66,7 +70,7 @@ DECIMAL_TYPE("DECIMAL", java.sql.Types.DECIMAL, TTypeId.DECIMAL_TYPE, - false, false), + true, false, false), ARRAY_TYPE("ARRAY", java.sql.Types.VARCHAR, TTypeId.STRING_TYPE, @@ -91,26 +95,35 @@ private final String name; private final TTypeId tType; private final int javaSQLType; + private final boolean isQualified; private final boolean isComplex; private final boolean isCollection; - - Type(String name, int javaSQLType, TTypeId tType, boolean isComplex, boolean isCollection) { + Type(String name, int javaSQLType, TTypeId tType, boolean isQualified, boolean isComplex, boolean isCollection) { this.name = name; this.javaSQLType = javaSQLType; this.tType = tType; + this.isQualified = isQualified; this.isComplex = isComplex; this.isCollection = isCollection; } + Type(String name, int javaSQLType, TTypeId tType, boolean isComplex, boolean isCollection) { + this(name, javaSQLType, tType, false, isComplex, isCollection); + } + Type(String name, int javaSqlType, TTypeId tType) { - this(name, javaSqlType, tType, false, false); + this(name, javaSqlType, tType, false, false, false); } public boolean isPrimitiveType() { return !isComplex; } + public boolean isQualifiedType() { + return isQualified; + } + public boolean isComplexType() { return isComplex; } @@ -135,7 +148,7 @@ public static Type getType(String name) { for (Type type : values()) { if (name.equalsIgnoreCase(type.name)) { return type; - } else if (type.isComplexType()) { + } else if (type.isQualifiedType() || type.isComplexType()) { if (name.toUpperCase().startsWith(type.name)) { return type; } diff --git service/src/java/org/apache/hive/service/cli/TypeDescriptor.java service/src/java/org/apache/hive/service/cli/TypeDescriptor.java index b4817ad..49a24e9 100644 --- service/src/java/org/apache/hive/service/cli/TypeDescriptor.java +++ service/src/java/org/apache/hive/service/cli/TypeDescriptor.java @@ -20,6 +20,11 @@ import java.util.List; +import org.apache.hadoop.hive.metastore.api.FieldSchema; +import org.apache.hadoop.hive.serde2.typeinfo.BaseTypeParams; +import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; import org.apache.hive.service.cli.thrift.TPrimitiveTypeEntry; import org.apache.hive.service.cli.thrift.TTypeDesc; import org.apache.hive.service.cli.thrift.TTypeEntry; @@ -32,6 +37,7 @@ private final Type type; private String typeName = null; + private TypeQualifiers typeQualifiers = null; public TypeDescriptor(Type type) { this.type = type; @@ -41,21 +47,39 @@ public TypeDescriptor(TTypeDesc tTypeDesc) { List tTypeEntries = tTypeDesc.getTypes(); TPrimitiveTypeEntry top = tTypeEntries.get(0).getPrimitiveEntry(); this.type = Type.getType(top.getType()); + if (top.isSetTypeQualifiers()) { + setTypeQualifiers(TypeQualifiers.fromTTypeQualifiers(top.getTypeQualifiers())); + } } public TypeDescriptor(String typeName) { this.type = Type.getType(typeName); if (this.type.isComplexType()) { this.typeName = typeName; + } else if (this.type.isQualifiedType()) { + TypeInfo pti = TypeInfoFactory.getPrimitiveTypeInfo(typeName); + BaseTypeParams typeParams = ((PrimitiveTypeInfo) pti).getTypeParams(); + if (typeParams != null) { + setTypeQualifiers(TypeQualifiers.fromBaseTypeParams(typeParams)); + } } } + public TypeDescriptor(FieldSchema fieldSchema) { + this(fieldSchema.getType()); + } + public Type getType() { return type; } public TTypeDesc toTTypeDesc() { - TTypeEntry entry = TTypeEntry.primitiveEntry(new TPrimitiveTypeEntry(type.toTType())); + TPrimitiveTypeEntry primitiveEntry = new TPrimitiveTypeEntry(type.toTType()); + if (getTypeQualifiers() != null) { + primitiveEntry.setTypeQualifiers(getTypeQualifiers().toTTypeQualifiers()); + } + TTypeEntry entry = TTypeEntry.primitiveEntry(primitiveEntry); + TTypeDesc desc = new TTypeDesc(); desc.addToTypes(entry); return desc; @@ -68,4 +92,12 @@ public String getTypeName() { return type.getName(); } } + + public TypeQualifiers getTypeQualifiers() { + return typeQualifiers; + } + + public void setTypeQualifiers(TypeQualifiers typeQualifiers) { + this.typeQualifiers = typeQualifiers; + } } diff --git service/src/java/org/apache/hive/service/cli/TypeQualifiers.java service/src/java/org/apache/hive/service/cli/TypeQualifiers.java new file mode 100644 index 0000000..fd2f7d1 --- /dev/null +++ service/src/java/org/apache/hive/service/cli/TypeQualifiers.java @@ -0,0 +1,82 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hive.service.cli; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.hadoop.hive.serde2.typeinfo.BaseTypeParams; +import org.apache.hive.service.cli.thrift.TCLIServiceConstants; +import org.apache.hive.service.cli.thrift.TTypeQualifierValue; +import org.apache.hive.service.cli.thrift.TTypeQualifiers; + +public class TypeQualifiers { + private Integer characterMaximumLength; + + public TypeQualifiers() {} + + public Integer getCharacterMaximumLength() { + return characterMaximumLength; + } + public void setCharacterMaximumLength(int characterMaximumLength) { + this.characterMaximumLength = characterMaximumLength; + } + + public TTypeQualifiers toTTypeQualifiers() { + TTypeQualifiers ret = null; + + Map qMap = new HashMap(); + if (getCharacterMaximumLength() != null) { + TTypeQualifierValue val = new TTypeQualifierValue(); + val.setI32Value(getCharacterMaximumLength().intValue()); + qMap.put(TCLIServiceConstants.CHARACTER_MAXIMUM_LENGTH, val); + } + + if (qMap.size() > 0) { + ret = new TTypeQualifiers(qMap); + } + + return ret; + } + + public static TypeQualifiers fromTTypeQualifiers(TTypeQualifiers ttq) { + TypeQualifiers ret = null; + if (ttq != null) { + ret = new TypeQualifiers(); + Map tqMap = ttq.getQualifiers(); + + if (tqMap.containsKey(TCLIServiceConstants.CHARACTER_MAXIMUM_LENGTH)) { + ret.setCharacterMaximumLength( + tqMap.get(TCLIServiceConstants.CHARACTER_MAXIMUM_LENGTH).getI32Value()); + } + } + return ret; + } + + public static TypeQualifiers fromBaseTypeParams(BaseTypeParams typeParams) { + TypeQualifiers ret = null; + if (typeParams != null) { + ret = new TypeQualifiers(); + if (typeParams.hasCharacterMaximumLength()) { + ret.setCharacterMaximumLength(typeParams.getCharacterMaximumLength()); + } + } + return ret; + } +}