| // 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. |
| |
| #include "service/hs2-util.h" |
| |
| #include "common/logging.h" |
| #include "exprs/scalar-expr-evaluator.h" |
| #include "runtime/decimal-value.inline.h" |
| #include "runtime/raw-value.inline.h" |
| #include "runtime/row-batch.h" |
| #include "runtime/types.h" |
| #include "util/bit-util.h" |
| |
| #include <gutil/strings/substitute.h> |
| |
| #include "common/names.h" |
| |
| using namespace apache::hive::service::cli; |
| using namespace impala; |
| using namespace strings; |
| |
| // Set the null indicator bit for row 'row_idx', assuming this will be called for |
| // successive increasing values of row_idx. If 'is_null' is true, the row_idx'th bit will |
| // be set in 'nulls' (taking the LSB as bit 0). If 'is_null' is false, the row_idx'th bit |
| // will be unchanged. If 'nulls' does not contain 'row_idx' bits, it will be extended by |
| // one byte. |
| inline void SetNullBit(uint32_t row_idx, bool is_null, string* nulls) { |
| DCHECK_LE(row_idx / 8, nulls->size()); |
| int16_t mod_8 = row_idx % 8; |
| if (mod_8 == 0) (*nulls) += '\0'; |
| (*nulls)[row_idx / 8] |= (1 << mod_8) * is_null; |
| } |
| |
| inline bool GetNullBit(const string& nulls, uint32_t row_idx) { |
| DCHECK_LE(row_idx / 8, nulls.size()); |
| return nulls[row_idx / 8] & (1 << row_idx % 8); |
| } |
| |
| void impala::StitchNulls(uint32_t num_rows_before, uint32_t num_rows_added, |
| uint32_t start_idx, const string& from, string* to) { |
| // Round up to power-of-two to avoid accidentally quadratic behaviour from repeated |
| // small increases in size. |
| to->reserve(BitUtil::RoundUpToPowerOfTwo((num_rows_before + num_rows_added + 7) / 8)); |
| |
| // TODO: This is very inefficient, since we could conceivably go one byte at a time |
| // (although the operands should stay live in registers in the loop). However doing this |
| // more efficiently leads to very complex code: we have to deal with the fact that |
| // 'start_idx' and 'num_rows_before' might both lead to offsets into the null bitset |
| // that don't start on a byte boundary. We should revisit this, ideally with a good |
| // bitset implementation. |
| for (int i = 0; i < num_rows_added; ++i) { |
| SetNullBit(num_rows_before + i, GetNullBit(from, i + start_idx), to); |
| } |
| } |
| |
| // For V6 and above |
| void impala::TColumnValueToHS2TColumn(const TColumnValue& col_val, |
| const TColumnType& type, uint32_t row_idx, thrift::TColumn* column) { |
| string* nulls; |
| bool is_null; |
| switch (type.types[0].scalar_type.type) { |
| case TPrimitiveType::NULL_TYPE: |
| case TPrimitiveType::BOOLEAN: |
| is_null = !col_val.__isset.bool_val; |
| column->boolVal.values.push_back(col_val.bool_val); |
| nulls = &column->boolVal.nulls; |
| break; |
| case TPrimitiveType::TINYINT: |
| is_null = !col_val.__isset.byte_val; |
| column->byteVal.values.push_back(col_val.byte_val); |
| nulls = &column->byteVal.nulls; |
| break; |
| case TPrimitiveType::SMALLINT: |
| is_null = !col_val.__isset.short_val; |
| column->i16Val.values.push_back(col_val.short_val); |
| nulls = &column->i16Val.nulls; |
| break; |
| case TPrimitiveType::INT: |
| is_null = !col_val.__isset.int_val; |
| column->i32Val.values.push_back(col_val.int_val); |
| nulls = &column->i32Val.nulls; |
| break; |
| case TPrimitiveType::BIGINT: |
| is_null = !col_val.__isset.long_val; |
| column->i64Val.values.push_back(col_val.long_val); |
| nulls = &column->i64Val.nulls; |
| break; |
| case TPrimitiveType::FLOAT: |
| case TPrimitiveType::DOUBLE: |
| is_null = !col_val.__isset.double_val; |
| column->doubleVal.values.push_back(col_val.double_val); |
| nulls = &column->doubleVal.nulls; |
| break; |
| case TPrimitiveType::TIMESTAMP: |
| case TPrimitiveType::DATE: |
| case TPrimitiveType::STRING: |
| case TPrimitiveType::CHAR: |
| case TPrimitiveType::VARCHAR: |
| case TPrimitiveType::DECIMAL: |
| is_null = !col_val.__isset.string_val; |
| column->stringVal.values.push_back(col_val.string_val); |
| nulls = &column->stringVal.nulls; |
| break; |
| default: |
| DCHECK(false) << "Unhandled type: " |
| << TypeToString(ThriftToType(type.types[0].scalar_type.type)); |
| return; |
| } |
| |
| SetNullBit(row_idx, is_null, nulls); |
| } |
| |
| // Specialised per-type implementations of ExprValuesToHS2TColumn. |
| |
| // Helper to reserve space in hs2Vals->values and hs2Vals->nulls for the values that the |
| // different implementations of ExprValuesToHS2TColumn will write. |
| template <typename T> |
| void ReserveSpace(int num_rows, uint32_t output_row_idx, T* hs2Vals) { |
| DCHECK_GE(num_rows, 0); |
| int64_t num_output_rows = output_row_idx + num_rows; |
| int64_t num_null_bytes = BitUtil::RoundUpNumBytes(num_output_rows); |
| // Round up reserve() arguments to power-of-two to avoid accidentally quadratic |
| // behaviour from repeated small increases in size. |
| hs2Vals->values.reserve(BitUtil::RoundUpToPowerOfTwo(num_output_rows)); |
| hs2Vals->nulls.reserve(BitUtil::RoundUpToPowerOfTwo(num_null_bytes)); |
| } |
| |
| // Implementation for BOOL. |
| static void BoolExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, RowBatch* batch, |
| int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->boolVal); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| BooleanVal val = expr_eval->GetBooleanVal(it.Get()); |
| column->boolVal.values.push_back(val.val); |
| SetNullBit(output_row_idx, val.is_null, &column->boolVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for TINYINT. |
| static void TinyIntExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, RowBatch* batch, |
| int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->byteVal); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| TinyIntVal val = expr_eval->GetTinyIntVal(it.Get()); |
| column->byteVal.values.push_back(val.val); |
| SetNullBit(output_row_idx, val.is_null, &column->byteVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for SMALLINT. |
| static void SmallIntExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, |
| RowBatch* batch, int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->i16Val); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| SmallIntVal val = expr_eval->GetSmallIntVal(it.Get()); |
| column->i16Val.values.push_back(val.val); |
| SetNullBit(output_row_idx, val.is_null, &column->i16Val.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for INT. |
| static void IntExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, RowBatch* batch, |
| int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->i32Val); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| DCHECK_EQ(output_row_idx, column->i32Val.values.size()); |
| IntVal val = expr_eval->GetIntVal(it.Get()); |
| column->i32Val.values.push_back(val.val); |
| SetNullBit(output_row_idx, val.is_null, &column->i32Val.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for BIGINT. |
| static void BigIntExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, RowBatch* batch, |
| int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->i64Val); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| BigIntVal val = expr_eval->GetBigIntVal(it.Get()); |
| column->i64Val.values.push_back(val.val); |
| SetNullBit(output_row_idx, val.is_null, &column->i64Val.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for FLOAT. |
| static void FloatExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, RowBatch* batch, |
| int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->doubleVal); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| FloatVal val = expr_eval->GetFloatVal(it.Get()); |
| column->doubleVal.values.push_back(val.val); |
| SetNullBit(output_row_idx, val.is_null, &column->doubleVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for DOUBLE. |
| static void DoubleExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, RowBatch* batch, |
| int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->doubleVal); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| DoubleVal val = expr_eval->GetDoubleVal(it.Get()); |
| column->doubleVal.values.push_back(val.val); |
| SetNullBit(output_row_idx, val.is_null, &column->doubleVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for TIMESTAMP. |
| static void TimestampExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, |
| RowBatch* batch, int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->stringVal); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| TimestampVal val = expr_eval->GetTimestampVal(it.Get()); |
| column->stringVal.values.emplace_back(); |
| if (!val.is_null) { |
| TimestampValue value = TimestampValue::FromTimestampVal(val); |
| RawValue::PrintValue( |
| &value, TYPE_TIMESTAMP, -1, &(column->stringVal.values.back())); |
| } |
| SetNullBit(output_row_idx, val.is_null, &column->stringVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for DATE. |
| static void DateExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, |
| RowBatch* batch, int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->stringVal); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| DateVal val = expr_eval->GetDateVal(it.Get()); |
| column->stringVal.values.emplace_back(); |
| if (!val.is_null) { |
| DateValue value = DateValue::FromDateVal(val); |
| RawValue::PrintValue( |
| &value, TYPE_DATE, -1, &(column->stringVal.values.back())); |
| } |
| SetNullBit(output_row_idx, val.is_null, &column->stringVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for STRING and VARCHAR. |
| static void StringExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, RowBatch* batch, |
| int start_idx, int num_rows, uint32_t output_row_idx, |
| apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->stringVal); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| StringVal val = expr_eval->GetStringVal(it.Get()); |
| if (val.is_null) { |
| column->stringVal.values.emplace_back(); |
| } else { |
| column->stringVal.values.emplace_back(reinterpret_cast<char*>(val.ptr), val.len); |
| } |
| SetNullBit(output_row_idx, val.is_null, &column->stringVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // Implementation for CHAR. |
| static void CharExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, |
| const TColumnType& type, RowBatch* batch, int start_idx, int num_rows, |
| uint32_t output_row_idx, apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->stringVal); |
| ColumnType char_type = ColumnType::CreateCharType(type.types[0].scalar_type.len); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| StringVal val = expr_eval->GetStringVal(it.Get()); |
| if (val.is_null) { |
| column->stringVal.values.emplace_back(); |
| } else { |
| column->stringVal.values.emplace_back( |
| reinterpret_cast<const char*>(val.ptr), char_type.len); |
| } |
| SetNullBit(output_row_idx, val.is_null, &column->stringVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| static void DecimalExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, |
| const TColumnType& type, RowBatch* batch, int start_idx, int num_rows, |
| uint32_t output_row_idx, apache::hive::service::cli::thrift::TColumn* column) { |
| ReserveSpace(num_rows, output_row_idx, &column->stringVal); |
| FOREACH_ROW_LIMIT(batch, start_idx, num_rows, it) { |
| DecimalVal val = expr_eval->GetDecimalVal(it.Get()); |
| const ColumnType& decimalType = ColumnType::FromThrift(type); |
| if (val.is_null) { |
| column->stringVal.values.emplace_back(); |
| } else { |
| switch (decimalType.GetByteSize()) { |
| case 4: |
| column->stringVal.values.emplace_back( |
| Decimal4Value(val.val4).ToString(decimalType)); |
| break; |
| case 8: |
| column->stringVal.values.emplace_back( |
| Decimal8Value(val.val8).ToString(decimalType)); |
| break; |
| case 16: |
| column->stringVal.values.emplace_back( |
| Decimal16Value(val.val16).ToString(decimalType)); |
| break; |
| default: |
| DCHECK(false) << "bad type: " << decimalType; |
| } |
| } |
| SetNullBit(output_row_idx, val.is_null, &column->stringVal.nulls); |
| ++output_row_idx; |
| } |
| } |
| |
| // For V6 and above |
| void impala::ExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval, |
| const TColumnType& type, RowBatch* batch, int start_idx, int num_rows, |
| uint32_t output_row_idx, apache::hive::service::cli::thrift::TColumn* column) { |
| // Dispatch to a templated function for the loop over rows. This avoids branching on |
| // the type for every row. |
| // TODO: instead of relying on stamped out implementations, we could codegen this loop |
| // to inline the expression evaluation into the loop body. |
| switch (type.types[0].scalar_type.type) { |
| case TPrimitiveType::NULL_TYPE: |
| case TPrimitiveType::BOOLEAN: |
| BoolExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::TINYINT: |
| TinyIntExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::SMALLINT: |
| SmallIntExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::INT: |
| IntExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::BIGINT: |
| BigIntExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::FLOAT: |
| FloatExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::DOUBLE: |
| DoubleExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::DATE: |
| DateExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| break; |
| case TPrimitiveType::TIMESTAMP: |
| TimestampExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::STRING: |
| case TPrimitiveType::VARCHAR: |
| StringExprValuesToHS2TColumn( |
| expr_eval, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::CHAR: |
| CharExprValuesToHS2TColumn( |
| expr_eval, type, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| case TPrimitiveType::DECIMAL: { |
| DecimalExprValuesToHS2TColumn( |
| expr_eval, type, batch, start_idx, num_rows, output_row_idx, column); |
| return; |
| } |
| default: |
| DCHECK(false) << "Unhandled type: " |
| << TypeToString(ThriftToType(type.types[0].scalar_type.type)); |
| } |
| } |
| |
| // For V1 -> V5 |
| void impala::TColumnValueToHS2TColumnValue(const TColumnValue& col_val, |
| const TColumnType& type, thrift::TColumnValue* hs2_col_val) { |
| // TODO: Handle complex types. |
| DCHECK_EQ(1, type.types.size()); |
| DCHECK_EQ(TTypeNodeType::SCALAR, type.types[0].type); |
| DCHECK_EQ(true, type.types[0].__isset.scalar_type); |
| switch (type.types[0].scalar_type.type) { |
| case TPrimitiveType::BOOLEAN: |
| hs2_col_val->__isset.boolVal = true; |
| hs2_col_val->boolVal.value = col_val.bool_val; |
| hs2_col_val->boolVal.__isset.value = col_val.__isset.bool_val; |
| break; |
| case TPrimitiveType::TINYINT: |
| hs2_col_val->__isset.byteVal = true; |
| hs2_col_val->byteVal.value = col_val.byte_val; |
| hs2_col_val->byteVal.__isset.value = col_val.__isset.byte_val; |
| break; |
| case TPrimitiveType::SMALLINT: |
| hs2_col_val->__isset.i16Val = true; |
| hs2_col_val->i16Val.value = col_val.short_val; |
| hs2_col_val->i16Val.__isset.value = col_val.__isset.short_val; |
| break; |
| case TPrimitiveType::INT: |
| hs2_col_val->__isset.i32Val = true; |
| hs2_col_val->i32Val.value = col_val.int_val; |
| hs2_col_val->i32Val.__isset.value = col_val.__isset.int_val; |
| break; |
| case TPrimitiveType::BIGINT: |
| hs2_col_val->__isset.i64Val = true; |
| hs2_col_val->i64Val.value = col_val.long_val; |
| hs2_col_val->i64Val.__isset.value = col_val.__isset.long_val; |
| break; |
| case TPrimitiveType::FLOAT: |
| case TPrimitiveType::DOUBLE: |
| hs2_col_val->__isset.doubleVal = true; |
| hs2_col_val->doubleVal.value = col_val.double_val; |
| hs2_col_val->doubleVal.__isset.value = col_val.__isset.double_val; |
| break; |
| case TPrimitiveType::DECIMAL: |
| case TPrimitiveType::STRING: |
| case TPrimitiveType::TIMESTAMP: |
| case TPrimitiveType::DATE: |
| case TPrimitiveType::VARCHAR: |
| case TPrimitiveType::CHAR: |
| // HiveServer2 requires timestamp to be presented as string. Note that the .thrift |
| // spec says it should be a BIGINT; AFAICT Hive ignores that and produces a string. |
| hs2_col_val->__isset.stringVal = true; |
| hs2_col_val->stringVal.__isset.value = col_val.__isset.string_val; |
| if (col_val.__isset.string_val) { |
| hs2_col_val->stringVal.value = col_val.string_val; |
| } |
| break; |
| default: |
| DCHECK(false) << "bad type: " |
| << TypeToString(ThriftToType(type.types[0].scalar_type.type)); |
| break; |
| } |
| } |
| |
| // For V1 -> V5 |
| void impala::ExprValueToHS2TColumnValue(const void* value, const TColumnType& type, |
| thrift::TColumnValue* hs2_col_val) { |
| bool not_null = (value != NULL); |
| // TODO: Handle complex types. |
| DCHECK_EQ(1, type.types.size()); |
| DCHECK_EQ(TTypeNodeType::SCALAR, type.types[0].type); |
| DCHECK_EQ(1, type.types[0].__isset.scalar_type); |
| switch (type.types[0].scalar_type.type) { |
| case TPrimitiveType::NULL_TYPE: |
| // Set NULLs in the bool_val. |
| hs2_col_val->__isset.boolVal = true; |
| hs2_col_val->boolVal.__isset.value = false; |
| break; |
| case TPrimitiveType::BOOLEAN: |
| hs2_col_val->__isset.boolVal = true; |
| if (not_null) hs2_col_val->boolVal.value = *reinterpret_cast<const bool*>(value); |
| hs2_col_val->boolVal.__isset.value = not_null; |
| break; |
| case TPrimitiveType::TINYINT: |
| hs2_col_val->__isset.byteVal = true; |
| if (not_null) hs2_col_val->byteVal.value = *reinterpret_cast<const int8_t*>(value); |
| hs2_col_val->byteVal.__isset.value = not_null; |
| break; |
| case TPrimitiveType::SMALLINT: |
| hs2_col_val->__isset.i16Val = true; |
| if (not_null) hs2_col_val->i16Val.value = *reinterpret_cast<const int16_t*>(value); |
| hs2_col_val->i16Val.__isset.value = not_null; |
| break; |
| case TPrimitiveType::INT: |
| hs2_col_val->__isset.i32Val = true; |
| if (not_null) hs2_col_val->i32Val.value = *reinterpret_cast<const int32_t*>(value); |
| hs2_col_val->i32Val.__isset.value = not_null; |
| break; |
| case TPrimitiveType::BIGINT: |
| hs2_col_val->__isset.i64Val = true; |
| if (not_null) hs2_col_val->i64Val.value = *reinterpret_cast<const int64_t*>(value); |
| hs2_col_val->i64Val.__isset.value = not_null; |
| break; |
| case TPrimitiveType::FLOAT: |
| hs2_col_val->__isset.doubleVal = true; |
| if (not_null) hs2_col_val->doubleVal.value = *reinterpret_cast<const float*>(value); |
| hs2_col_val->doubleVal.__isset.value = not_null; |
| break; |
| case TPrimitiveType::DOUBLE: |
| hs2_col_val->__isset.doubleVal = true; |
| if (not_null) { |
| hs2_col_val->doubleVal.value = *reinterpret_cast<const double*>(value); |
| } |
| hs2_col_val->doubleVal.__isset.value = not_null; |
| break; |
| case TPrimitiveType::STRING: |
| case TPrimitiveType::VARCHAR: |
| hs2_col_val->__isset.stringVal = true; |
| hs2_col_val->stringVal.__isset.value = not_null; |
| if (not_null) { |
| const StringValue* string_val = reinterpret_cast<const StringValue*>(value); |
| hs2_col_val->stringVal.value.assign(static_cast<char*>(string_val->ptr), |
| string_val->len); |
| } |
| break; |
| case TPrimitiveType::CHAR: |
| hs2_col_val->__isset.stringVal = true; |
| hs2_col_val->stringVal.__isset.value = not_null; |
| if (not_null) { |
| ColumnType char_type = ColumnType::CreateCharType(type.types[0].scalar_type.len); |
| hs2_col_val->stringVal.value.assign( |
| reinterpret_cast<const char*>(value), char_type.len); |
| } |
| break; |
| case TPrimitiveType::DATE: |
| // HiveServer2 requires date to be presented as string. |
| hs2_col_val->__isset.stringVal = true; |
| hs2_col_val->stringVal.__isset.value = not_null; |
| if (not_null) { |
| hs2_col_val->stringVal.value = |
| reinterpret_cast<const DateValue*>(value)->ToString(); |
| } |
| break; |
| case TPrimitiveType::TIMESTAMP: |
| // HiveServer2 requires timestamp to be presented as string. |
| hs2_col_val->__isset.stringVal = true; |
| hs2_col_val->stringVal.__isset.value = not_null; |
| if (not_null) { |
| RawValue::PrintValue(value, TYPE_TIMESTAMP, -1, &(hs2_col_val->stringVal.value)); |
| } |
| break; |
| case TPrimitiveType::DECIMAL: { |
| // HiveServer2 requires decimal to be presented as string. |
| hs2_col_val->__isset.stringVal = true; |
| hs2_col_val->stringVal.__isset.value = not_null; |
| const ColumnType& decimalType = ColumnType::FromThrift(type); |
| if (not_null) { |
| switch (decimalType.GetByteSize()) { |
| case 4: |
| hs2_col_val->stringVal.value = |
| reinterpret_cast<const Decimal4Value*>(value)->ToString(decimalType); |
| break; |
| case 8: |
| hs2_col_val->stringVal.value = |
| reinterpret_cast<const Decimal8Value*>(value)->ToString(decimalType); |
| break; |
| case 16: |
| hs2_col_val->stringVal.value = |
| reinterpret_cast<const Decimal16Value*>(value)->ToString(decimalType); |
| break; |
| default: |
| DCHECK(false) << "bad type: " << decimalType; |
| } |
| } |
| break; |
| } |
| default: |
| DCHECK(false) << "bad type: " |
| << TypeToString(ThriftToType(type.types[0].scalar_type.type)); |
| break; |
| } |
| } |
| |
| template<typename T> |
| void PrintVal(const T& val, ostream* ss) { |
| if (val.__isset.value) { |
| (*ss) << val.value; |
| } else { |
| (*ss) << "NULL"; |
| } |
| } |
| |
| // Specialisation for byte values that would otherwise be interpreted as character values, |
| // not integers, when printed to the stringstream. |
| template<> |
| void PrintVal(const apache::hive::service::cli::thrift::TByteValue& val, ostream* ss) { |
| if (val.__isset.value) { |
| (*ss) << static_cast<int16_t>(val.value); |
| } else { |
| (*ss) << "NULL"; |
| } |
| } |
| |
| void impala::PrintTColumnValue( |
| const apache::hive::service::cli::thrift::TColumnValue& colval, stringstream* out) { |
| if (colval.__isset.boolVal) { |
| if (colval.boolVal.__isset.value) { |
| (*out) << ((colval.boolVal.value) ? "true" : "false"); |
| } else { |
| (*out) << "NULL"; |
| } |
| } else if (colval.__isset.doubleVal) { |
| PrintVal(colval.doubleVal, out); |
| } else if (colval.__isset.byteVal) { |
| PrintVal(colval.byteVal, out); |
| } else if (colval.__isset.i32Val) { |
| PrintVal(colval.i32Val, out); |
| } else if (colval.__isset.i16Val) { |
| PrintVal(colval.i16Val, out); |
| } else if (colval.__isset.i64Val) { |
| PrintVal(colval.i64Val, out); |
| } else if (colval.__isset.stringVal) { |
| PrintVal(colval.stringVal, out); |
| } else { |
| (*out) << "NULL"; |
| } |
| } |