duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/extension/json/json_functions/json_value.cpp

@@ -0,0 +1,42 @@
+#include "json_executors.hpp"
+
+namespace duckdb {
+
+static inline string_t ValueFromVal(yyjson_val *val, yyjson_alc *alc, Vector &, ValidityMask &mask, idx_t idx) {
+	switch (yyjson_get_tag(val)) {
+	case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
+	case YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE:
+		mask.SetInvalid(idx);
+		return string_t {};
+	default:
+		return JSONCommon::WriteVal<yyjson_val>(val, alc);
+	}
+}
+
+static void ValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	JSONExecutors::BinaryExecute<string_t>(args, state, result, ValueFromVal);
+}
+
+static void ValueManyFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	JSONExecutors::ExecuteMany<string_t>(args, state, result, ValueFromVal);
+}
+
+static void GetValueFunctionsInternal(ScalarFunctionSet &set, const LogicalType &input_type) {
+	set.AddFunction(ScalarFunction({input_type, LogicalType::BIGINT}, LogicalType::JSON(), ValueFunction,
+	                               JSONReadFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
+	set.AddFunction(ScalarFunction({input_type, LogicalType::VARCHAR}, LogicalType::JSON(), ValueFunction,
+	                               JSONReadFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
+	set.AddFunction(ScalarFunction({input_type, LogicalType::LIST(LogicalType::VARCHAR)},
+	                               LogicalType::LIST(LogicalType::JSON()), ValueManyFunction,
+	                               JSONReadManyFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
+}
+
+ScalarFunctionSet JSONFunctions::GetValueFunction() {
+	// The value function is just like the extract function but returns NULL if the JSON is not a scalar value
+	ScalarFunctionSet set("json_value");
+	GetValueFunctionsInternal(set, LogicalType::VARCHAR);
+	GetValueFunctionsInternal(set, LogicalType::JSON());
+	return set;
+}
+
+} // namespace duckdb

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -99,8 +99,8 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto
 	bind_data.type = JSONScanType::READ_JSON;
 
 	// Convert structure to logical type
-	auto type =
-	    JSONStructure::StructureToType(context, node, bind_data.max_depth, bind_data.field_appearance_threshold);
+	auto type = JSONStructure::StructureToType(context, node, bind_data.max_depth, bind_data.field_appearance_threshold,
+	                                           bind_data.map_inference_threshold);
 
 	// Auto-detect record type
 	if (bind_data.options.record_type == JSONRecordType::AUTO_DETECT) {
@@ -145,6 +145,9 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 	bind_data->Bind(context, input);
 
 	for (auto &kv : input.named_parameters) {
+		if (kv.second.IsNull()) {
+			throw BinderException("Cannot use NULL as function argument");
+		}
 		auto loption = StringUtil::Lower(kv.first);
 		if (kv.second.IsNull()) {
 			throw BinderException("read_json parameter \"%s\" cannot be NULL.", loption);
@@ -196,6 +199,16 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 				    "read_json_auto \"field_appearance_threshold\" parameter must be between 0 and 1");
 			}
 			bind_data->field_appearance_threshold = arg;
+		} else if (loption == "map_inference_threshold") {
+			auto arg = BigIntValue::Get(kv.second);
+			if (arg == -1) {
+				bind_data->map_inference_threshold = NumericLimits<idx_t>::Maximum();
+			} else if (arg >= 0) {
+				bind_data->map_inference_threshold = arg;
+			} else {
+				throw BinderException("read_json_auto \"map_inference_threshold\" parameter must be 0 or positive, "
+				                      "or -1 to disable map inference for consistent objects.");
+			}
 		} else if (loption == "dateformat" || loption == "date_format") {
 			auto format_string = StringValue::Get(kv.second);
 			if (StringUtil::Lower(format_string) == "iso") {
@@ -380,6 +393,7 @@ TableFunctionSet CreateJSONFunctionInfo(string name, shared_ptr<JSONScanInfo> in
 	table_function.named_parameters["maximum_depth"] = LogicalType::BIGINT;
 	table_function.named_parameters["field_appearance_threshold"] = LogicalType::DOUBLE;
 	table_function.named_parameters["convert_strings_to_integers"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["map_inference_threshold"] = LogicalType::BIGINT;
 	return MultiFileReader::CreateFunctionSet(table_function);
 }
 

package/src/duckdb/extension/json/json_functions/read_json_objects.cpp

@@ -33,8 +33,9 @@ static void ReadJSONObjectsFunction(ClientContext &context, TableFunctionInput &
 
 	if (!gstate.names.empty()) {
 		// Create the strings without copying them
-		auto strings = FlatVector::GetData<string_t>(output.data[0]);
-		auto &validity = FlatVector::Validity(output.data[0]);
+		const auto col_idx = gstate.column_indices[0];
+		auto strings = FlatVector::GetData<string_t>(output.data[col_idx]);
+		auto &validity = FlatVector::Validity(output.data[col_idx]);
 		for (idx_t i = 0; i < count; i++) {
 			if (objects[i]) {
 				strings[i] = string_t(units[i].pointer, units[i].size);

package/src/duckdb/extension/json/json_functions.cpp

@@ -160,13 +160,17 @@ vector<ScalarFunctionSet> JSONFunctions::GetScalarFunctions() {
 	// Other
 	functions.push_back(GetArrayLengthFunction());
 	functions.push_back(GetContainsFunction());
+	functions.push_back(GetExistsFunction());
 	functions.push_back(GetKeysFunction());
 	functions.push_back(GetTypeFunction());
 	functions.push_back(GetValidFunction());
+	functions.push_back(GetValueFunction());
 	functions.push_back(GetSerializePlanFunction());
 	functions.push_back(GetSerializeSqlFunction());
 	functions.push_back(GetDeserializeSqlFunction());
 
+	functions.push_back(GetPrettyPrintFunction());
+
 	return functions;
 }
 
@@ -196,7 +200,7 @@ vector<TableFunctionSet> JSONFunctions::GetTableFunctions() {
 
 unique_ptr<TableRef> JSONFunctions::ReadJSONReplacement(ClientContext &context, ReplacementScanInput &input,
                                                         optional_ptr<ReplacementScanData> data) {
-	auto &table_name = input.table_name;
+	auto table_name = ReplacementScan::GetFullPath(input);
 	if (!ReplacementScan::CanReplace(table_name, {"json", "jsonl", "ndjson"})) {
 		return nullptr;
 	}

package/src/duckdb/extension/json/json_scan.cpp

@@ -29,6 +29,9 @@ void JSONScanData::Bind(ClientContext &context, TableFunctionBindInput &input) {
 	auto_detect = info.auto_detect;
 
 	for (auto &kv : input.named_parameters) {
+		if (kv.second.IsNull()) {
+			throw BinderException("Cannot use NULL as function argument");
+		}
 		if (MultiFileReader().ParseOption(kv.first, kv.second, options.file_options, context)) {
 			continue;
 		}
@@ -600,20 +603,18 @@ bool JSONScanLocalState::ReadNextBuffer(JSONScanGlobalState &gstate) {
 		// Open the file if it is not yet open
 		if (!current_reader->IsOpen()) {
 			current_reader->OpenJSONFile();
-			if (current_reader->GetFileHandle().FileSize() == 0 && !current_reader->GetFileHandle().IsPipe()) {
-				current_reader->GetFileHandle().Close();
-				// Skip over empty files
-				if (gstate.enable_parallel_scans) {
-					TryIncrementFileIndex(gstate);
-				}
-				continue;
-			}
 		}
 
 		// Auto-detect if we haven't yet done this during the bind
 		if (gstate.bind_data.options.record_type == JSONRecordType::AUTO_DETECT ||
 		    current_reader->GetFormat() == JSONFormat::AUTO_DETECT) {
-			ReadAndAutoDetect(gstate, buffer, buffer_index);
+			bool file_done = false;
+			ReadAndAutoDetect(gstate, buffer, buffer_index, file_done);
+			if (file_done) {
+				TryIncrementFileIndex(gstate);
+				lock_guard<mutex> reader_guard(current_reader->lock);
+				current_reader->GetFileHandle().Close();
+			}
 		}
 
 		if (gstate.enable_parallel_scans) {
@@ -653,9 +654,8 @@ bool JSONScanLocalState::ReadNextBuffer(JSONScanGlobalState &gstate) {
 }
 
 void JSONScanLocalState::ReadAndAutoDetect(JSONScanGlobalState &gstate, AllocatedData &buffer,
-                                           optional_idx &buffer_index) {
+                                           optional_idx &buffer_index, bool &file_done) {
 	// We have to detect the JSON format - hold the gstate lock while we do this
-	bool file_done = false;
 	if (!ReadNextBufferInternal(gstate, buffer, buffer_index, file_done)) {
 		return;
 	}
@@ -980,8 +980,9 @@ void JSONScan::ComplexFilterPushdown(ClientContext &context, LogicalGet &get, Fu
 
 	SimpleMultiFileList file_list(std::move(data.files));
 
+	MultiFilePushdownInfo info(get);
 	auto filtered_list =
-	    MultiFileReader().ComplexFilterPushdown(context, file_list, data.options.file_options, get, filters);
+	    MultiFileReader().ComplexFilterPushdown(context, file_list, data.options.file_options, info, filters);
 	if (filtered_list) {
 		MultiFileReader().PruneReaders(data, *filtered_list);
 		data.files = filtered_list->GetAllFiles();

package/src/duckdb/extension/json/serialize_json.cpp

@@ -44,6 +44,7 @@ void JSONScanData::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<double>(113, "field_appearance_threshold", field_appearance_threshold, 0.1);
 	serializer.WritePropertyWithDefault<idx_t>(114, "maximum_sample_files", maximum_sample_files, 32);
 	serializer.WritePropertyWithDefault<bool>(115, "convert_strings_to_integers", convert_strings_to_integers, false);
+	serializer.WritePropertyWithDefault<idx_t>(116, "map_inference_threshold", map_inference_threshold, 25);
 }
 
 unique_ptr<JSONScanData> JSONScanData::Deserialize(Deserializer &deserializer) {
@@ -71,9 +72,10 @@ unique_ptr<JSONScanData> JSONScanData::Deserialize(Deserializer &deserializer) {
 	result->max_depth = max_depth;
 	result->transform_options = transform_options;
 	result->names = std::move(names);
-	deserializer.ReadPropertyWithDefault<double>(113, "field_appearance_threshold", result->field_appearance_threshold, 0.1);
-	deserializer.ReadPropertyWithDefault<idx_t>(114, "maximum_sample_files", result->maximum_sample_files, 32);
-	deserializer.ReadPropertyWithDefault<bool>(115, "convert_strings_to_integers", result->convert_strings_to_integers, false);
+	deserializer.ReadPropertyWithExplicitDefault<double>(113, "field_appearance_threshold", result->field_appearance_threshold, 0.1);
+	deserializer.ReadPropertyWithExplicitDefault<idx_t>(114, "maximum_sample_files", result->maximum_sample_files, 32);
+	deserializer.ReadPropertyWithExplicitDefault<bool>(115, "convert_strings_to_integers", result->convert_strings_to_integers, false);
+	deserializer.ReadPropertyWithExplicitDefault<idx_t>(116, "map_inference_threshold", result->map_inference_threshold, 25);
 	return result;
 }
 

package/src/duckdb/extension/parquet/column_reader.cpp

@@ -1,23 +1,25 @@
 #include "column_reader.hpp"
 
 #include "boolean_column_reader.hpp"
+#include "brotli/decode.h"
 #include "callback_column_reader.hpp"
 #include "cast_column_reader.hpp"
 #include "duckdb.hpp"
+#include "expression_column_reader.hpp"
 #include "list_column_reader.hpp"
+#include "lz4.hpp"
 #include "miniz_wrapper.hpp"
+#include "null_column_reader.hpp"
 #include "parquet_decimal_utils.hpp"
 #include "parquet_reader.hpp"
 #include "parquet_timestamp.hpp"
 #include "row_number_column_reader.hpp"
 #include "snappy.h"
 #include "string_column_reader.hpp"
-#include "null_column_reader.hpp"
 #include "struct_column_reader.hpp"
 #include "templated_column_reader.hpp"
 #include "utf8proc_wrapper.hpp"
 #include "zstd.h"
-#include "lz4.hpp"
 
 #ifndef DUCKDB_AMALGAMATION
 #include "duckdb/common/helper.hpp"
@@ -343,7 +345,9 @@ void ColumnReader::DecompressInternal(CompressionCodec::type codec, const_data_p
 		break;
 	}
 	case CompressionCodec::LZ4_RAW: {
-		auto res = duckdb_lz4::LZ4_decompress_safe(const_char_ptr_cast(src), char_ptr_cast(dst), src_size, dst_size);
+		auto res =
+		    duckdb_lz4::LZ4_decompress_safe(const_char_ptr_cast(src), char_ptr_cast(dst),
+		                                    UnsafeNumericCast<int32_t>(src_size), UnsafeNumericCast<int32_t>(dst_size));
 		if (res != NumericCast<int>(dst_size)) {
 			throw std::runtime_error("LZ4 decompression failure");
 		}
@@ -373,12 +377,26 @@ void ColumnReader::DecompressInternal(CompressionCodec::type codec, const_data_p
 		}
 		break;
 	}
+	case CompressionCodec::BROTLI: {
+		auto state = duckdb_brotli::BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
+		size_t total_out = 0;
+		auto src_size_size_t = NumericCast<size_t>(src_size);
+		auto dst_size_size_t = NumericCast<size_t>(dst_size);
+
+		auto res = duckdb_brotli::BrotliDecoderDecompressStream(state, &src_size_size_t, &src, &dst_size_size_t, &dst,
+		                                                        &total_out);
+		if (res != duckdb_brotli::BROTLI_DECODER_RESULT_SUCCESS) {
+			throw std::runtime_error("Brotli Decompression failure");
+		}
+		duckdb_brotli::BrotliDecoderDestroyInstance(state);
+		break;
+	}
 
 	default: {
 		std::stringstream codec_name;
 		codec_name << codec;
 		throw std::runtime_error("Unsupported compression codec \"" + codec_name.str() +
-		                         "\". Supported options are uncompressed, gzip, lz4_raw, snappy or zstd");
+		                         "\". Supported options are uncompressed, brotli, gzip, lz4_raw, snappy or zstd");
 	}
 	}
 }
@@ -641,7 +659,7 @@ uint32_t StringColumnReader::VerifyString(const char *str_data, uint32_t str_len
 
 void StringColumnReader::Dictionary(shared_ptr<ResizeableBuffer> data, idx_t num_entries) {
 	dict = std::move(data);
-	dict_strings = unique_ptr<string_t[]>(new string_t[num_entries]);
+	dict_strings = unsafe_unique_ptr<string_t[]>(new string_t[num_entries]);
 	for (idx_t dict_idx = 0; dict_idx < num_entries; dict_idx++) {
 		uint32_t str_len;
 		if (fixed_width_string_length == 0) {
@@ -741,7 +759,7 @@ void StringColumnReader::DeltaByteArray(uint8_t *defines, idx_t num_values, parq
 			result_mask.SetInvalid(row_idx + result_offset);
 			continue;
 		}
-		if (filter[row_idx + result_offset]) {
+		if (filter.test(row_idx + result_offset)) {
 			if (delta_offset >= byte_array_count) {
 				throw IOException("DELTA_BYTE_ARRAY - length mismatch between values and byte array lengths (attempted "
 				                  "read of %d from %d entries) - corrupt file?",
@@ -773,8 +791,7 @@ void StringColumnReader::PlainReference(shared_ptr<ByteBuffer> plain_data, Vecto
 }
 
 string_t StringParquetValueConversion::DictRead(ByteBuffer &dict, uint32_t &offset, ColumnReader &reader) {
-	auto &dict_strings = reader.Cast<StringColumnReader>().dict_strings;
-	return dict_strings[offset];
+	return reader.Cast<StringColumnReader>().dict_strings[offset];
 }
 
 string_t StringParquetValueConversion::PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
@@ -794,6 +811,18 @@ void StringParquetValueConversion::PlainSkip(ByteBuffer &plain_data, ColumnReade
 	plain_data.inc(str_len);
 }
 
+bool StringParquetValueConversion::PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
+	return true;
+}
+
+string_t StringParquetValueConversion::UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
+	return PlainRead(plain_data, reader);
+}
+
+void StringParquetValueConversion::UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
+	PlainSkip(plain_data, reader);
+}
+
 //===--------------------------------------------------------------------===//
 // List Column Reader
 //===--------------------------------------------------------------------===//
@@ -952,8 +981,9 @@ unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p, c
 		row_group_offset_min += row_groups[i].num_rows;
 	}
 
-	NumericStats::SetMin(stats, Value::BIGINT(row_group_offset_min));
-	NumericStats::SetMax(stats, Value::BIGINT(row_group_offset_min + row_groups[row_group_idx_p].num_rows));
+	NumericStats::SetMin(stats, Value::BIGINT(UnsafeNumericCast<int64_t>(row_group_offset_min)));
+	NumericStats::SetMax(
+	    stats, Value::BIGINT(UnsafeNumericCast<int64_t>(row_group_offset_min + row_groups[row_group_idx_p].num_rows)));
 	stats.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
 	return stats.ToUnique();
 }
@@ -972,7 +1002,7 @@ idx_t RowNumberColumnReader::Read(uint64_t num_values, parquet_filter_t &filter,
 
 	auto data_ptr = FlatVector::GetData<int64_t>(result);
 	for (idx_t i = 0; i < num_values; i++) {
-		data_ptr[i] = row_group_offset++;
+		data_ptr[i] = UnsafeNumericCast<int64_t>(row_group_offset++);
 	}
 	return num_values;
 }
@@ -1010,7 +1040,7 @@ idx_t CastColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data
 		intermediate_vector.Flatten(amount);
 		auto &validity = FlatVector::Validity(intermediate_vector);
 		for (idx_t i = 0; i < amount; i++) {
-			if (!filter[i]) {
+			if (!filter.test(i)) {
 				validity.SetInvalid(i);
 			}
 		}
@@ -1019,14 +1049,33 @@ idx_t CastColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data
 	bool all_succeeded = VectorOperations::DefaultTryCast(intermediate_vector, result, amount, &error_message);
 	if (!all_succeeded) {
 		string extended_error;
-		extended_error =
-		    StringUtil::Format("In file \"%s\" the column \"%s\" has type %s, but we are trying to read it as type %s.",
-		                       reader.file_name, schema.name, intermediate_vector.GetType(), result.GetType());
-		extended_error += "\nThis can happen when reading multiple Parquet files. The schema information is taken from "
-		                  "the first Parquet file by default. Possible solutions:\n";
-		extended_error += "* Enable the union_by_name=True option to combine the schema of all Parquet files "
-		                  "(duckdb.org/docs/data/multiple_files/combining_schemas)\n";
-		extended_error += "* Use a COPY statement to automatically derive types from an existing table.";
+		if (!reader.table_columns.empty()) {
+			// COPY .. FROM
+			extended_error = StringUtil::Format(
+			    "In file \"%s\" the column \"%s\" has type %s, but we are trying to load it into column ",
+			    reader.file_name, schema.name, intermediate_vector.GetType());
+			if (FileIdx() < reader.table_columns.size()) {
+				extended_error += "\"" + reader.table_columns[FileIdx()] + "\" ";
+			}
+			extended_error += StringUtil::Format("with type %s.", result.GetType());
+			extended_error += "\nThis means the Parquet schema does not match the schema of the table.";
+			extended_error += "\nPossible solutions:";
+			extended_error += "\n* Insert by name instead of by position using \"INSERT INTO tbl BY NAME SELECT * FROM "
+			                  "read_parquet(...)\"";
+			extended_error += "\n* Manually specify which columns to insert using \"INSERT INTO tbl SELECT ... FROM "
+			                  "read_parquet(...)\"";
+		} else {
+			// read_parquet() with multiple files
+			extended_error = StringUtil::Format(
+			    "In file \"%s\" the column \"%s\" has type %s, but we are trying to read it as type %s.",
+			    reader.file_name, schema.name, intermediate_vector.GetType(), result.GetType());
+			extended_error +=
+			    "\nThis can happen when reading multiple Parquet files. The schema information is taken from "
+			    "the first Parquet file by default. Possible solutions:\n";
+			extended_error += "* Enable the union_by_name=True option to combine the schema of all Parquet files "
+			                  "(duckdb.org/docs/data/multiple_files/combining_schemas)\n";
+			extended_error += "* Use a COPY statement to automatically derive types from an existing table.";
+		}
 		throw ConversionException(
 		    "In Parquet reader of file \"%s\": failed to cast column \"%s\" from type %s to %s: %s\n\n%s",
 		    reader.file_name, schema.name, intermediate_vector.GetType(), result.GetType(), error_message,
@@ -1043,6 +1092,59 @@ idx_t CastColumnReader::GroupRowsAvailable() {
 	return child_reader->GroupRowsAvailable();
 }
 
+//===--------------------------------------------------------------------===//
+// Expression Column Reader
+//===--------------------------------------------------------------------===//
+ExpressionColumnReader::ExpressionColumnReader(ClientContext &context, unique_ptr<ColumnReader> child_reader_p,
+                                               unique_ptr<Expression> expr_p)
+    : ColumnReader(child_reader_p->Reader(), expr_p->return_type, child_reader_p->Schema(), child_reader_p->FileIdx(),
+                   child_reader_p->MaxDefine(), child_reader_p->MaxRepeat()),
+      child_reader(std::move(child_reader_p)), expr(std::move(expr_p)), executor(context, expr.get()) {
+	vector<LogicalType> intermediate_types {child_reader->Type()};
+	intermediate_chunk.Initialize(reader.allocator, intermediate_types);
+}
+
+unique_ptr<BaseStatistics> ExpressionColumnReader::Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) {
+	// expression stats is not supported (yet)
+	return nullptr;
+}
+
+void ExpressionColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
+                                            TProtocol &protocol_p) {
+	child_reader->InitializeRead(row_group_idx_p, columns, protocol_p);
+}
+
+idx_t ExpressionColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out,
+                                   data_ptr_t repeat_out, Vector &result) {
+	intermediate_chunk.Reset();
+	auto &intermediate_vector = intermediate_chunk.data[0];
+
+	auto amount = child_reader->Read(num_values, filter, define_out, repeat_out, intermediate_vector);
+	if (!filter.all()) {
+		// work-around for filters: set all values that are filtered to NULL to prevent the cast from failing on
+		// uninitialized data
+		intermediate_vector.Flatten(amount);
+		auto &validity = FlatVector::Validity(intermediate_vector);
+		for (idx_t i = 0; i < amount; i++) {
+			if (!filter[i]) {
+				validity.SetInvalid(i);
+			}
+		}
+	}
+	// Execute the expression
+	intermediate_chunk.SetCardinality(amount);
+	executor.ExecuteExpression(intermediate_chunk, result);
+	return amount;
+}
+
+void ExpressionColumnReader::Skip(idx_t num_values) {
+	child_reader->Skip(num_values);
+}
+
+idx_t ExpressionColumnReader::GroupRowsAvailable() {
+	return child_reader->GroupRowsAvailable();
+}
+
 //===--------------------------------------------------------------------===//
 // Struct Column Reader
 //===--------------------------------------------------------------------===//
@@ -1147,8 +1249,7 @@ idx_t StructColumnReader::GroupRowsAvailable() {
 template <class DUCKDB_PHYSICAL_TYPE, bool FIXED_LENGTH>
 struct DecimalParquetValueConversion {
 	static DUCKDB_PHYSICAL_TYPE DictRead(ByteBuffer &dict, uint32_t &offset, ColumnReader &reader) {
-		auto dict_ptr = reinterpret_cast<DUCKDB_PHYSICAL_TYPE *>(dict.ptr);
-		return dict_ptr[offset];
+		return reinterpret_cast<DUCKDB_PHYSICAL_TYPE *>(dict.ptr)[offset];
 	}
 
 	static DUCKDB_PHYSICAL_TYPE PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
@@ -1170,6 +1271,18 @@ struct DecimalParquetValueConversion {
 		uint32_t decimal_len = FIXED_LENGTH ? reader.Schema().type_length : plain_data.read<uint32_t>();
 		plain_data.inc(decimal_len);
 	}
+
+	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
+		return true;
+	}
+
+	static DUCKDB_PHYSICAL_TYPE UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
+		return PlainRead(plain_data, reader);
+	}
+
+	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
+		PlainSkip(plain_data, reader);
+	}
 };
 
 template <class DUCKDB_PHYSICAL_TYPE, bool FIXED_LENGTH>
@@ -1236,7 +1349,7 @@ double ParquetDecimalUtils::ReadDecimalValue(const_data_ptr_t pointer, idx_t siz
 			res_ptr[sizeof(uint64_t) - k - 1] = positive ? byte : byte ^ 0xFF;
 		}
 		res *= double(NumericLimits<uint64_t>::Maximum()) + 1;
-		res += input;
+		res += static_cast<double>(input);
 	}
 	if (!positive) {
 		res += 1;
@@ -1262,8 +1375,7 @@ unique_ptr<ColumnReader> ParquetDecimalUtils::CreateReader(ParquetReader &reader
 //===--------------------------------------------------------------------===//
 struct UUIDValueConversion {
 	static hugeint_t DictRead(ByteBuffer &dict, uint32_t &offset, ColumnReader &reader) {
-		auto dict_ptr = reinterpret_cast<hugeint_t *>(dict.ptr);
-		return dict_ptr[offset];
+		return reinterpret_cast<hugeint_t *>(dict.ptr)[offset];
 	}
 
 	static hugeint_t ReadParquetUUID(const_data_ptr_t input) {
@@ -1278,23 +1390,32 @@ struct UUIDValueConversion {
 			result.lower <<= 8;
 			result.lower += input[i];
 		}
-		result.upper = unsigned_upper;
-		result.upper ^= (int64_t(1) << 63);
+		result.upper = static_cast<int64_t>(unsigned_upper ^ (uint64_t(1) << 63));
 		return result;
 	}
 
 	static hugeint_t PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		idx_t byte_len = sizeof(hugeint_t);
-		plain_data.available(byte_len);
-		auto res = ReadParquetUUID(const_data_ptr_cast(plain_data.ptr));
-
-		plain_data.inc(byte_len);
-		return res;
+		plain_data.available(sizeof(hugeint_t));
+		return UnsafePlainRead(plain_data, reader);
 	}
 
 	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
 		plain_data.inc(sizeof(hugeint_t));
 	}
+
+	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
+		return plain_data.check_available(count * sizeof(hugeint_t));
+	}
+
+	static hugeint_t UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
+		auto res = ReadParquetUUID(const_data_ptr_cast(plain_data.ptr));
+		plain_data.unsafe_inc(sizeof(hugeint_t));
+		return res;
+	}
+
+	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
+		plain_data.unsafe_inc(sizeof(hugeint_t));
+	}
 };
 
 class UUIDColumnReader : public TemplatedColumnReader<hugeint_t, UUIDValueConversion> {
@@ -1322,30 +1443,39 @@ struct IntervalValueConversion {
 	static constexpr const idx_t PARQUET_INTERVAL_SIZE = 12;
 
 	static interval_t DictRead(ByteBuffer &dict, uint32_t &offset, ColumnReader &reader) {
-		auto dict_ptr = reinterpret_cast<interval_t *>(dict.ptr);
-		return dict_ptr[offset];
+		return reinterpret_cast<interval_t *>(dict.ptr)[offset];
 	}
 
 	static interval_t ReadParquetInterval(const_data_ptr_t input) {
 		interval_t result;
-		result.months = Load<uint32_t>(input);
-		result.days = Load<uint32_t>(input + sizeof(uint32_t));
+		result.months = Load<int32_t>(input);
+		result.days = Load<int32_t>(input + sizeof(uint32_t));
 		result.micros = int64_t(Load<uint32_t>(input + sizeof(uint32_t) * 2)) * 1000;
 		return result;
 	}
 
 	static interval_t PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-		idx_t byte_len = PARQUET_INTERVAL_SIZE;
-		plain_data.available(byte_len);
-		auto res = ReadParquetInterval(const_data_ptr_cast(plain_data.ptr));
-
-		plain_data.inc(byte_len);
-		return res;
+		plain_data.available(PARQUET_INTERVAL_SIZE);
+		return UnsafePlainRead(plain_data, reader);
 	}
 
 	static void PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
 		plain_data.inc(PARQUET_INTERVAL_SIZE);
 	}
+
+	static bool PlainAvailable(const ByteBuffer &plain_data, const idx_t count) {
+		return plain_data.check_available(count * PARQUET_INTERVAL_SIZE);
+	}
+
+	static interval_t UnsafePlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
+		auto res = ReadParquetInterval(const_data_ptr_cast(plain_data.ptr));
+		plain_data.unsafe_inc(PARQUET_INTERVAL_SIZE);
+		return res;
+	}
+
+	static void UnsafePlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
+		plain_data.unsafe_inc(PARQUET_INTERVAL_SIZE);
+	}
 };
 
 class IntervalColumnReader : public TemplatedColumnReader<interval_t, IntervalValueConversion> {
@@ -1464,6 +1594,39 @@ unique_ptr<ColumnReader> ColumnReader::CreateReader(ParquetReader &reader, const
 			break;
 		}
 		break;
+	case LogicalTypeId::TIMESTAMP_NS:
+		switch (schema_p.type) {
+		case Type::INT96:
+			return make_uniq<CallbackColumnReader<Int96, timestamp_ns_t, ImpalaTimestampToTimestampNS>>(
+			    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+		case Type::INT64:
+			if (schema_p.__isset.logicalType && schema_p.logicalType.__isset.TIMESTAMP) {
+				if (schema_p.logicalType.TIMESTAMP.unit.__isset.MILLIS) {
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampMsToTimestampNs>>(
+					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+				} else if (schema_p.logicalType.TIMESTAMP.unit.__isset.MICROS) {
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampUsToTimestampNs>>(
+					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+				} else if (schema_p.logicalType.TIMESTAMP.unit.__isset.NANOS) {
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampNsToTimestampNs>>(
+					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+				}
+			} else if (schema_p.__isset.converted_type) {
+				switch (schema_p.converted_type) {
+				case ConvertedType::TIMESTAMP_MICROS:
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampUsToTimestampNs>>(
+					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+				case ConvertedType::TIMESTAMP_MILLIS:
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_ns_t, ParquetTimestampMsToTimestampNs>>(
+					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+				default:
+					break;
+				}
+			}
+		default:
+			break;
+		}
+		break;
 	case LogicalTypeId::DATE:
 		return make_uniq<CallbackColumnReader<int32_t, date_t, ParquetIntToDate>>(reader, type_p, schema_p, file_idx_p,
 		                                                                          max_define, max_repeat);