vendor: Update vendored sources to duckdb/duckdb@920b39a

Read support for Parquet Float16 (duckdb/duckdb#16395)
Fix issue duckdb/duckdb#16377 (duckdb/duckdb#16391)

Author: Antonov548

src/duckdb/extension/parquet/column_reader.cpp

@@ -14,12 +14,15 @@
 #include "reader/null_column_reader.hpp"
 #include "parquet_reader.hpp"
 #include "parquet_timestamp.hpp"
+#include "parquet_float16.hpp"
+
 #include "reader/row_number_column_reader.hpp"
 #include "snappy.h"
 #include "reader/string_column_reader.hpp"
 #include "reader/struct_column_reader.hpp"
 #include "reader/templated_column_reader.hpp"
 #include "reader/uuid_column_reader.hpp"
+
 #include "zstd.h"
 
 #include "duckdb/storage/table/column_segment.hpp"
@@ -766,6 +769,9 @@ unique_ptr<ColumnReader> ColumnReader::CreateReader(ParquetReader &reader, const
 	case LogicalTypeId::BIGINT:
 		return make_uniq<TemplatedColumnReader<int64_t, TemplatedParquetValueConversion<int64_t>>>(reader, schema);
 	case LogicalTypeId::FLOAT:
+		if (schema.type_info == ParquetExtraTypeInfo::FLOAT16) {
+			return make_uniq<CallbackColumnReader<uint16_t, float, Float16ToFloat32>>(reader, schema);
+		}
 		return make_uniq<TemplatedColumnReader<float, TemplatedParquetValueConversion<float>>>(reader, schema);
 	case LogicalTypeId::DOUBLE:
 		if (schema.type_info == ParquetExtraTypeInfo::DECIMAL_BYTE_ARRAY) {

src/duckdb/extension/parquet/include/parquet_column_schema.hpp

@@ -23,7 +23,8 @@ enum class ParquetExtraTypeInfo {
 	UNIT_MICROS,
 	DECIMAL_BYTE_ARRAY,
 	DECIMAL_INT32,
-	DECIMAL_INT64
+	DECIMAL_INT64,
+	FLOAT16
 };
 
 struct ParquetColumnSchema {

src/duckdb/extension/parquet/include/parquet_float16.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// parquet_timestamp.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+float Float16ToFloat32(const uint16_t &float16_value);
+
+} // namespace duckdb

src/duckdb/extension/parquet/parquet_float16.cpp

@@ -0,0 +1,45 @@
+#include "parquet_float16.hpp"
+
+#include "duckdb.hpp"
+#ifndef DUCKDB_AMALGAMATION
+
+#endif
+
+namespace duckdb {
+
+float Float16ToFloat32(const uint16_t &float16_value) {
+	uint32_t sign = float16_value >> 15;
+	uint32_t exponent = (float16_value >> 10) & 0x1F;
+	uint32_t fraction = (float16_value & 0x3FF);
+	uint32_t float32_value;
+	if (exponent == 0) {
+		if (fraction == 0) {
+			// zero
+			float32_value = (sign << 31);
+		} else {
+			// can be represented as ordinary value in float32
+			// 2 ** -14 * 0.0101
+			// => 2 ** -16 * 1.0100
+			// int int_exponent = -14;
+			exponent = 127 - 14;
+			while ((fraction & (1 << 10)) == 0) {
+				// int_exponent--;
+				exponent--;
+				fraction <<= 1;
+			}
+			fraction &= 0x3FF;
+			// int_exponent += 127;
+			float32_value = (sign << 31) | (exponent << 23) | (fraction << 13);
+		}
+	} else if (exponent == 0x1F) {
+		/* Inf or NaN */
+		float32_value = (sign << 31) | (0xFF << 23) | (fraction << 13);
+	} else {
+		/* ordinary number */
+		float32_value = (sign << 31) | ((exponent + (127 - 15)) << 23) | (fraction << 13);
+	}
+
+	return *((float *)&float32_value);
+}
+
+} // namespace duckdb

src/duckdb/extension/parquet/parquet_metadata.cpp

@@ -424,6 +424,9 @@ Value ParquetLogicalTypeToString(const duckdb_parquet::LogicalType &type, bool i
 	if (type.__isset.UUID) {
 		return Value(PrintParquetElementToString(type.UUID));
 	}
+	if (type.__isset.FLOAT16) {
+		return Value(PrintParquetElementToString(type.FLOAT16));
+	}
 	return Value();
 }
 

src/duckdb/extension/parquet/parquet_reader.cpp

@@ -133,6 +133,11 @@ LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele, Parquet
 			if (s_ele.type == Type::FIXED_LEN_BYTE_ARRAY) {
 				return LogicalType::UUID;
 			}
+		} else if (s_ele.logicalType.__isset.FLOAT16) {
+			if (s_ele.type == Type::FIXED_LEN_BYTE_ARRAY && s_ele.type_length == 2) {
+				schema.type_info = ParquetExtraTypeInfo::FLOAT16;
+				return LogicalType::FLOAT;
+			}
 		} else if (s_ele.logicalType.__isset.TIMESTAMP) {
 			if (s_ele.logicalType.TIMESTAMP.unit.__isset.MILLIS) {
 				schema.type_info = ParquetExtraTypeInfo::UNIT_MS;

src/duckdb/extension/parquet/parquet_statistics.cpp

@@ -3,6 +3,7 @@
 #include "duckdb.hpp"
 #include "parquet_decimal_utils.hpp"
 #include "parquet_timestamp.hpp"
+#include "parquet_float16.hpp"
 #include "parquet_reader.hpp"
 #include "reader/string_column_reader.hpp"
 #include "reader/struct_column_reader.hpp"
@@ -93,10 +94,18 @@ Value ParquetStatisticsUtils::ConvertValueInternal(const LogicalType &type, cons
 		}
 		return Value::BIGINT(Load<int64_t>(stats_data));
 	case LogicalTypeId::FLOAT: {
-		if (stats.size() != sizeof(float)) {
-			throw InvalidInputException("Incorrect stats size for type FLOAT");
+		float val;
+		if (schema_ele.type_info == ParquetExtraTypeInfo::FLOAT16) {
+			if (stats.size() != sizeof(uint16_t)) {
+				throw InvalidInputException("Incorrect stats size for type FLOAT16");
+			}
+			val = Float16ToFloat32(Load<uint16_t>(stats_data));
+		} else {
+			if (stats.size() != sizeof(float)) {
+				throw InvalidInputException("Incorrect stats size for type FLOAT");
+			}
+			val = Load<float>(stats_data);
 		}
-		auto val = Load<float>(stats_data);
 		if (!Value::FloatIsFinite(val)) {
 			return Value();
 		}

src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "1-dev750"
+#define DUCKDB_PATCH_VERSION "1-dev754"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 2
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.2.1-dev750"
+#define DUCKDB_VERSION "v1.2.1-dev754"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "c8cc956524"
+#define DUCKDB_SOURCE_ID "920b39ad96"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"