duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

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

@@ -5,7 +5,6 @@
 
 #include "boolean_column_reader.hpp"
 #include "cast_column_reader.hpp"
-#include "generated_column_reader.hpp"
 #include "row_number_column_reader.hpp"
 #include "callback_column_reader.hpp"
 #include "parquet_decimal_utils.hpp"
@@ -34,10 +33,69 @@ using duckdb_parquet::format::Encoding;
 using duckdb_parquet::format::PageType;
 using duckdb_parquet::format::Type;
 
-const uint32_t ParquetDecodeUtils::BITPACK_MASKS[] = {
-    0,       1,       3,        7,        15,       31,        63,        127,       255,        511,       1023,
-    2047,    4095,    8191,     16383,    32767,    65535,     131071,    262143,    524287,     1048575,   2097151,
-    4194303, 8388607, 16777215, 33554431, 67108863, 134217727, 268435455, 536870911, 1073741823, 2147483647};
+const uint64_t ParquetDecodeUtils::BITPACK_MASKS[] = {0,
+                                                      1,
+                                                      3,
+                                                      7,
+                                                      15,
+                                                      31,
+                                                      63,
+                                                      127,
+                                                      255,
+                                                      511,
+                                                      1023,
+                                                      2047,
+                                                      4095,
+                                                      8191,
+                                                      16383,
+                                                      32767,
+                                                      65535,
+                                                      131071,
+                                                      262143,
+                                                      524287,
+                                                      1048575,
+                                                      2097151,
+                                                      4194303,
+                                                      8388607,
+                                                      16777215,
+                                                      33554431,
+                                                      67108863,
+                                                      134217727,
+                                                      268435455,
+                                                      536870911,
+                                                      1073741823,
+                                                      2147483647,
+                                                      4294967295,
+                                                      8589934591,
+                                                      17179869183,
+                                                      34359738367,
+                                                      68719476735,
+                                                      137438953471,
+                                                      274877906943,
+                                                      549755813887,
+                                                      1099511627775,
+                                                      2199023255551,
+                                                      4398046511103,
+                                                      8796093022207,
+                                                      17592186044415,
+                                                      35184372088831,
+                                                      70368744177663,
+                                                      140737488355327,
+                                                      281474976710655,
+                                                      562949953421311,
+                                                      1125899906842623,
+                                                      2251799813685247,
+                                                      4503599627370495,
+                                                      9007199254740991,
+                                                      18014398509481983,
+                                                      36028797018963967,
+                                                      72057594037927935,
+                                                      144115188075855871,
+                                                      288230376151711743,
+                                                      576460752303423487,
+                                                      1152921504606846975,
+                                                      2305843009213693951,
+                                                      4611686018427387903};
 
 const uint8_t ParquetDecodeUtils::BITPACK_DLEN = 8;
 
@@ -120,7 +178,7 @@ idx_t ColumnReader::GroupRowsAvailable() {
 	return group_rows_available;
 }
 
-unique_ptr<BaseStatistics> ColumnReader::Stats(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns) {
+unique_ptr<BaseStatistics> ColumnReader::Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) {
 	if (Type().id() == LogicalTypeId::LIST || Type().id() == LogicalTypeId::STRUCT ||
 	    Type().id() == LogicalTypeId::MAP) {
 		return nullptr;
@@ -160,8 +218,7 @@ void ColumnReader::DictReference(Vector &result) {
 void ColumnReader::PlainReference(shared_ptr<ByteBuffer>, Vector &result) { // NOLINT
 }
 
-void ColumnReader::InitializeRead(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns,
-                                  TProtocol &protocol_p) {
+void ColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) {
 	D_ASSERT(file_idx < columns.size());
 	chunk = &columns[file_idx];
 	protocol = &protocol_p;
@@ -338,8 +395,8 @@ void ColumnReader::PrepareDataPage(PageHeader &page_hdr) {
 	if (HasRepeats()) {
 		uint32_t rep_length = is_v1 ? block->read<uint32_t>() : v2_header.repetition_levels_byte_length;
 		block->available(rep_length);
-		repeated_decoder = make_unique<RleBpDecoder>((const uint8_t *)block->ptr, rep_length,
-		                                             RleBpDecoder::ComputeBitWidth(max_repeat));
+		repeated_decoder =
+		    make_uniq<RleBpDecoder>((const uint8_t *)block->ptr, rep_length, RleBpDecoder::ComputeBitWidth(max_repeat));
 		block->inc(rep_length);
 	} else if (is_v2 && v2_header.repetition_levels_byte_length > 0) {
 		block->inc(v2_header.repetition_levels_byte_length);
@@ -348,8 +405,8 @@ void ColumnReader::PrepareDataPage(PageHeader &page_hdr) {
 	if (HasDefines()) {
 		uint32_t def_length = is_v1 ? block->read<uint32_t>() : v2_header.definition_levels_byte_length;
 		block->available(def_length);
-		defined_decoder = make_unique<RleBpDecoder>((const uint8_t *)block->ptr, def_length,
-		                                            RleBpDecoder::ComputeBitWidth(max_define));
+		defined_decoder =
+		    make_uniq<RleBpDecoder>((const uint8_t *)block->ptr, def_length, RleBpDecoder::ComputeBitWidth(max_define));
 		block->inc(def_length);
 	} else if (is_v2 && v2_header.definition_levels_byte_length > 0) {
 		block->inc(v2_header.definition_levels_byte_length);
@@ -361,7 +418,7 @@ void ColumnReader::PrepareDataPage(PageHeader &page_hdr) {
 		// where is it otherwise??
 		auto dict_width = block->read<uint8_t>();
 		// TODO somehow dict_width can be 0 ?
-		dict_decoder = make_unique<RleBpDecoder>((const uint8_t *)block->ptr, block->len, dict_width);
+		dict_decoder = make_uniq<RleBpDecoder>((const uint8_t *)block->ptr, block->len, dict_width);
 		block->inc(block->len);
 		break;
 	}
@@ -370,11 +427,11 @@ void ColumnReader::PrepareDataPage(PageHeader &page_hdr) {
 			throw std::runtime_error("RLE encoding is only supported for boolean data");
 		}
 		block->inc(sizeof(uint32_t));
-		rle_decoder = make_unique<RleBpDecoder>((const uint8_t *)block->ptr, block->len, 1);
+		rle_decoder = make_uniq<RleBpDecoder>((const uint8_t *)block->ptr, block->len, 1);
 		break;
 	}
 	case Encoding::DELTA_BINARY_PACKED: {
-		dbp_decoder = make_unique<DbpDecoder>((const uint8_t *)block->ptr, block->len);
+		dbp_decoder = make_uniq<DbpDecoder>((const uint8_t *)block->ptr, block->len);
 		block->inc(block->len);
 		break;
 	}
@@ -449,13 +506,13 @@ idx_t ColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, uint8_t
 			// TODO keep this in the state
 			auto read_buf = make_shared<ResizeableBuffer>();
 
-			switch (type.id()) {
-			case LogicalTypeId::INTEGER:
+			switch (type.InternalType()) {
+			case PhysicalType::INT32:
 				read_buf->resize(reader.allocator, sizeof(int32_t) * (read_now - null_count));
 				dbp_decoder->GetBatch<int32_t>(read_buf->ptr, read_now - null_count);
 
 				break;
-			case LogicalTypeId::BIGINT:
+			case PhysicalType::INT64:
 				read_buf->resize(reader.allocator, sizeof(int64_t) * (read_now - null_count));
 				dbp_decoder->GetBatch<int64_t>(read_buf->ptr, read_now - null_count);
 				break;
@@ -550,7 +607,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 = duckdb::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) {
@@ -569,7 +626,7 @@ void StringColumnReader::Dictionary(shared_ptr<ResizeableBuffer> data, idx_t num
 }
 
 static shared_ptr<ResizeableBuffer> ReadDbpData(Allocator &allocator, ResizeableBuffer &buffer, idx_t &value_count) {
-	auto decoder = make_unique<DbpDecoder>((const uint8_t *)buffer.ptr, buffer.len);
+	auto decoder = make_uniq<DbpDecoder>((const uint8_t *)buffer.ptr, buffer.len);
 	value_count = decoder->TotalValues();
 	auto result = make_shared<ResizeableBuffer>();
 	result->resize(allocator, sizeof(uint32_t) * value_count);
@@ -584,12 +641,13 @@ void StringColumnReader::PrepareDeltaLengthByteArray(ResizeableBuffer &buffer) {
 	auto length_buffer = ReadDbpData(reader.allocator, buffer, value_count);
 	if (value_count == 0) {
 		// no values
-		byte_array_data = make_unique<Vector>(LogicalType::VARCHAR, nullptr);
+		byte_array_data = make_uniq<Vector>(LogicalType::VARCHAR, nullptr);
 		return;
 	}
 	auto length_data = (uint32_t *)length_buffer->ptr;
-	byte_array_data = make_unique<Vector>(LogicalType::VARCHAR, value_count);
+	byte_array_data = make_uniq<Vector>(LogicalType::VARCHAR, value_count);
 	byte_array_count = value_count;
+	delta_offset = 0;
 	auto string_data = FlatVector::GetData<string_t>(*byte_array_data);
 	for (idx_t i = 0; i < value_count; i++) {
 		auto str_len = length_data[i];
@@ -610,13 +668,14 @@ void StringColumnReader::PrepareDeltaByteArray(ResizeableBuffer &buffer) {
 	}
 	if (prefix_count == 0) {
 		// no values
-		byte_array_data = make_unique<Vector>(LogicalType::VARCHAR, nullptr);
+		byte_array_data = make_uniq<Vector>(LogicalType::VARCHAR, nullptr);
 		return;
 	}
 	auto prefix_data = (uint32_t *)prefix_buffer->ptr;
 	auto suffix_data = (uint32_t *)suffix_buffer->ptr;
-	byte_array_data = make_unique<Vector>(LogicalType::VARCHAR, prefix_count);
+	byte_array_data = make_uniq<Vector>(LogicalType::VARCHAR, prefix_count);
 	byte_array_count = prefix_count;
+	delta_offset = 0;
 	auto string_data = FlatVector::GetData<string_t>(*byte_array_data);
 	for (idx_t i = 0; i < prefix_count; i++) {
 		auto str_len = prefix_data[i] + suffix_data[i];
@@ -658,6 +717,7 @@ void StringColumnReader::DeltaByteArray(uint8_t *defines, idx_t num_values, parq
 			delta_offset++;
 		}
 	}
+	StringVector::AddHeapReference(result, *byte_array_data);
 }
 
 class ParquetStringVectorBuffer : public VectorBuffer {
@@ -678,22 +738,22 @@ void StringColumnReader::PlainReference(shared_ptr<ByteBuffer> plain_data, Vecto
 }
 
 string_t StringParquetValueConversion::DictRead(ByteBuffer &dict, uint32_t &offset, ColumnReader &reader) {
-	auto &dict_strings = ((StringColumnReader &)reader).dict_strings;
+	auto &dict_strings = reader.Cast<StringColumnReader>().dict_strings;
 	return dict_strings[offset];
 }
 
 string_t StringParquetValueConversion::PlainRead(ByteBuffer &plain_data, ColumnReader &reader) {
-	auto &scr = ((StringColumnReader &)reader);
+	auto &scr = reader.Cast<StringColumnReader>();
 	uint32_t str_len = scr.fixed_width_string_length == 0 ? plain_data.read<uint32_t>() : scr.fixed_width_string_length;
 	plain_data.available(str_len);
-	auto actual_str_len = ((StringColumnReader &)reader).VerifyString(plain_data.ptr, str_len);
+	auto actual_str_len = reader.Cast<StringColumnReader>().VerifyString(plain_data.ptr, str_len);
 	auto ret_str = string_t(plain_data.ptr, actual_str_len);
 	plain_data.inc(str_len);
 	return ret_str;
 }
 
 void StringParquetValueConversion::PlainSkip(ByteBuffer &plain_data, ColumnReader &reader) {
-	auto &scr = ((StringColumnReader &)reader);
+	auto &scr = reader.Cast<StringColumnReader>();
 	uint32_t str_len = scr.fixed_width_string_length == 0 ? plain_data.read<uint32_t>() : scr.fixed_width_string_length;
 	plain_data.inc(str_len);
 }
@@ -804,7 +864,7 @@ idx_t ListColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, uint
 
 ListColumnReader::ListColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p,
                                    idx_t schema_idx_p, idx_t max_define_p, idx_t max_repeat_p,
-                                   unique_ptr<ColumnReader> child_column_reader_p)
+                                   duckdb::unique_ptr<ColumnReader> child_column_reader_p)
     : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p),
       child_column_reader(std::move(child_column_reader_p)),
       read_cache(reader.allocator, ListType::GetChildType(Type())), read_vector(read_cache), overflow_child_count(0) {
@@ -820,8 +880,8 @@ ListColumnReader::ListColumnReader(ParquetReader &reader, LogicalType type_p, co
 void ListColumnReader::ApplyPendingSkips(idx_t num_values) {
 	pending_skips -= num_values;
 
-	auto define_out = unique_ptr<uint8_t[]>(new uint8_t[num_values]);
-	auto repeat_out = unique_ptr<uint8_t[]>(new uint8_t[num_values]);
+	auto define_out = duckdb::unique_ptr<uint8_t[]>(new uint8_t[num_values]);
+	auto repeat_out = duckdb::unique_ptr<uint8_t[]>(new uint8_t[num_values]);
 
 	idx_t remaining = num_values;
 	idx_t read = 0;
@@ -839,22 +899,6 @@ void ListColumnReader::ApplyPendingSkips(idx_t num_values) {
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Generated Constant Column Reader
-//===--------------------------------------------------------------------===//
-GeneratedConstantColumnReader::GeneratedConstantColumnReader(ParquetReader &reader, LogicalType type_p,
-                                                             const SchemaElement &schema_p, idx_t schema_idx_p,
-                                                             idx_t max_define_p, idx_t max_repeat_p, Value constant_p)
-    : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p),
-      constant(std::move(constant_p)) {
-}
-idx_t GeneratedConstantColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, uint8_t *define_out,
-                                          uint8_t *repeat_out, Vector &result) {
-	result.SetValue(0, constant);
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	return num_values;
-}
-
 //===--------------------------------------------------------------------===//
 // Row NumberColumn Reader
 //===--------------------------------------------------------------------===//
@@ -863,9 +907,8 @@ RowNumberColumnReader::RowNumberColumnReader(ParquetReader &reader, LogicalType
     : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p) {
 }
 
-unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p,
-                                                        const std::vector<ColumnChunk> &columns) {
-	auto stats = make_unique<NumericStatistics>(type, StatisticsType::LOCAL_STATS);
+unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) {
+	auto stats = NumericStats::CreateUnknown(type);
 	auto &row_groups = reader.GetFileMetadata()->row_groups;
 	D_ASSERT(row_group_idx_p < row_groups.size());
 	idx_t row_group_offset_min = 0;
@@ -873,14 +916,13 @@ unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p,
 		row_group_offset_min += row_groups[i].num_rows;
 	}
 
-	stats->min = Value::BIGINT(row_group_offset_min);
-	stats->max = Value::BIGINT(row_group_offset_min + row_groups[row_group_idx_p].num_rows);
-
-	D_ASSERT(!stats->CanHaveNull() && stats->CanHaveNoNull());
-	return std::move(stats);
+	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));
+	stats.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
+	return stats.ToUnique();
 }
 
-void RowNumberColumnReader::InitializeRead(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns,
+void RowNumberColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
                                            TProtocol &protocol_p) {
 	row_group_offset = 0;
 	auto &row_groups = reader.GetFileMetadata()->row_groups;
@@ -902,7 +944,7 @@ idx_t RowNumberColumnReader::Read(uint64_t num_values, parquet_filter_t &filter,
 //===--------------------------------------------------------------------===//
 // Cast Column Reader
 //===--------------------------------------------------------------------===//
-CastColumnReader::CastColumnReader(unique_ptr<ColumnReader> child_reader_p, LogicalType target_type_p)
+CastColumnReader::CastColumnReader(duckdb::unique_ptr<ColumnReader> child_reader_p, LogicalType target_type_p)
     : ColumnReader(child_reader_p->Reader(), std::move(target_type_p), child_reader_p->Schema(),
                    child_reader_p->FileIdx(), child_reader_p->MaxDefine(), child_reader_p->MaxRepeat()),
       child_reader(std::move(child_reader_p)) {
@@ -910,12 +952,12 @@ CastColumnReader::CastColumnReader(unique_ptr<ColumnReader> child_reader_p, Logi
 	intermediate_chunk.Initialize(reader.allocator, intermediate_types);
 }
 
-unique_ptr<BaseStatistics> CastColumnReader::Stats(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns) {
+unique_ptr<BaseStatistics> CastColumnReader::Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) {
 	// casting stats is not supported (yet)
 	return nullptr;
 }
 
-void CastColumnReader::InitializeRead(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns,
+void CastColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
                                       TProtocol &protocol_p) {
 	child_reader->InitializeRead(row_group_idx_p, columns, protocol_p);
 }
@@ -954,7 +996,7 @@ idx_t CastColumnReader::GroupRowsAvailable() {
 //===--------------------------------------------------------------------===//
 StructColumnReader::StructColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p,
                                        idx_t schema_idx_p, idx_t max_define_p, idx_t max_repeat_p,
-                                       vector<unique_ptr<ColumnReader>> child_readers_p)
+                                       vector<duckdb::unique_ptr<ColumnReader>> child_readers_p)
     : ColumnReader(reader, std::move(type_p), schema_p, schema_idx_p, max_define_p, max_repeat_p),
       child_readers(std::move(child_readers_p)) {
 	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
@@ -965,7 +1007,7 @@ ColumnReader *StructColumnReader::GetChildReader(idx_t child_idx) {
 	return child_readers[child_idx].get();
 }
 
-void StructColumnReader::InitializeRead(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns,
+void StructColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
                                         TProtocol &protocol_p) {
 	for (auto &child : child_readers) {
 		child->InitializeRead(row_group_idx_p, columns, protocol_p);
@@ -1104,22 +1146,22 @@ protected:
 };
 
 template <bool FIXED_LENGTH>
-static unique_ptr<ColumnReader> CreateDecimalReaderInternal(ParquetReader &reader, const LogicalType &type_p,
-                                                            const SchemaElement &schema_p, idx_t file_idx_p,
-                                                            idx_t max_define, idx_t max_repeat) {
+static duckdb::unique_ptr<ColumnReader> CreateDecimalReaderInternal(ParquetReader &reader, const LogicalType &type_p,
+                                                                    const SchemaElement &schema_p, idx_t file_idx_p,
+                                                                    idx_t max_define, idx_t max_repeat) {
 	switch (type_p.InternalType()) {
 	case PhysicalType::INT16:
-		return make_unique<DecimalColumnReader<int16_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
-		                                                               max_repeat);
+		return make_uniq<DecimalColumnReader<int16_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
+		                                                             max_repeat);
 	case PhysicalType::INT32:
-		return make_unique<DecimalColumnReader<int32_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
-		                                                               max_repeat);
+		return make_uniq<DecimalColumnReader<int32_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
+		                                                             max_repeat);
 	case PhysicalType::INT64:
-		return make_unique<DecimalColumnReader<int64_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
-		                                                               max_repeat);
+		return make_uniq<DecimalColumnReader<int64_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
+		                                                             max_repeat);
 	case PhysicalType::INT128:
-		return make_unique<DecimalColumnReader<hugeint_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p,
-		                                                                 max_define, max_repeat);
+		return make_uniq<DecimalColumnReader<hugeint_t, FIXED_LENGTH>>(reader, type_p, schema_p, file_idx_p, max_define,
+		                                                               max_repeat);
 	default:
 		throw InternalException("Unrecognized type for Decimal");
 	}
@@ -1253,13 +1295,13 @@ unique_ptr<ColumnReader> CreateDecimalReader(ParquetReader &reader, const Logica
                                              idx_t max_repeat) {
 	switch (type_p.InternalType()) {
 	case PhysicalType::INT16:
-		return make_unique<TemplatedColumnReader<int16_t, TemplatedParquetValueConversion<T>>>(
+		return make_uniq<TemplatedColumnReader<int16_t, TemplatedParquetValueConversion<T>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case PhysicalType::INT32:
-		return make_unique<TemplatedColumnReader<int32_t, TemplatedParquetValueConversion<T>>>(
+		return make_uniq<TemplatedColumnReader<int32_t, TemplatedParquetValueConversion<T>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case PhysicalType::INT64:
-		return make_unique<TemplatedColumnReader<int64_t, TemplatedParquetValueConversion<T>>>(
+		return make_uniq<TemplatedColumnReader<int64_t, TemplatedParquetValueConversion<T>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	default:
 		throw NotImplementedException("Unimplemented internal type for CreateDecimalReader");
@@ -1271,62 +1313,62 @@ unique_ptr<ColumnReader> ColumnReader::CreateReader(ParquetReader &reader, const
                                                     idx_t max_repeat) {
 	switch (type_p.id()) {
 	case LogicalTypeId::BOOLEAN:
-		return make_unique<BooleanColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+		return make_uniq<BooleanColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::UTINYINT:
-		return make_unique<TemplatedColumnReader<uint8_t, TemplatedParquetValueConversion<uint32_t>>>(
+		return make_uniq<TemplatedColumnReader<uint8_t, TemplatedParquetValueConversion<uint32_t>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::USMALLINT:
-		return make_unique<TemplatedColumnReader<uint16_t, TemplatedParquetValueConversion<uint32_t>>>(
+		return make_uniq<TemplatedColumnReader<uint16_t, TemplatedParquetValueConversion<uint32_t>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::UINTEGER:
-		return make_unique<TemplatedColumnReader<uint32_t, TemplatedParquetValueConversion<uint32_t>>>(
+		return make_uniq<TemplatedColumnReader<uint32_t, TemplatedParquetValueConversion<uint32_t>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::UBIGINT:
-		return make_unique<TemplatedColumnReader<uint64_t, TemplatedParquetValueConversion<uint64_t>>>(
+		return make_uniq<TemplatedColumnReader<uint64_t, TemplatedParquetValueConversion<uint64_t>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::TINYINT:
-		return make_unique<TemplatedColumnReader<int8_t, TemplatedParquetValueConversion<int32_t>>>(
+		return make_uniq<TemplatedColumnReader<int8_t, TemplatedParquetValueConversion<int32_t>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::SMALLINT:
-		return make_unique<TemplatedColumnReader<int16_t, TemplatedParquetValueConversion<int32_t>>>(
+		return make_uniq<TemplatedColumnReader<int16_t, TemplatedParquetValueConversion<int32_t>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::INTEGER:
-		return make_unique<TemplatedColumnReader<int32_t, TemplatedParquetValueConversion<int32_t>>>(
+		return make_uniq<TemplatedColumnReader<int32_t, TemplatedParquetValueConversion<int32_t>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::BIGINT:
-		return make_unique<TemplatedColumnReader<int64_t, TemplatedParquetValueConversion<int64_t>>>(
+		return make_uniq<TemplatedColumnReader<int64_t, TemplatedParquetValueConversion<int64_t>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::FLOAT:
-		return make_unique<TemplatedColumnReader<float, TemplatedParquetValueConversion<float>>>(
+		return make_uniq<TemplatedColumnReader<float, TemplatedParquetValueConversion<float>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::DOUBLE:
-		return make_unique<TemplatedColumnReader<double, TemplatedParquetValueConversion<double>>>(
+		return make_uniq<TemplatedColumnReader<double, TemplatedParquetValueConversion<double>>>(
 		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
 		switch (schema_p.type) {
 		case Type::INT96:
-			return make_unique<CallbackColumnReader<Int96, timestamp_t, ImpalaTimestampToTimestamp>>(
+			return make_uniq<CallbackColumnReader<Int96, timestamp_t, ImpalaTimestampToTimestamp>>(
 			    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_unique<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMsToTimestamp>>(
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMsToTimestamp>>(
 					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 				} else if (schema_p.logicalType.TIMESTAMP.unit.__isset.MICROS) {
-					return make_unique<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMicrosToTimestamp>>(
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMicrosToTimestamp>>(
 					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 				} else if (schema_p.logicalType.TIMESTAMP.unit.__isset.NANOS) {
-					return make_unique<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampNsToTimestamp>>(
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampNsToTimestamp>>(
 					    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_unique<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMicrosToTimestamp>>(
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMicrosToTimestamp>>(
 					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 				case ConvertedType::TIMESTAMP_MILLIS:
-					return make_unique<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMsToTimestamp>>(
+					return make_uniq<CallbackColumnReader<int64_t, timestamp_t, ParquetTimestampMsToTimestamp>>(
 					    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 				default:
 					break;
@@ -1337,15 +1379,36 @@ unique_ptr<ColumnReader> ColumnReader::CreateReader(ParquetReader &reader, const
 		}
 		break;
 	case LogicalTypeId::DATE:
-		return make_unique<CallbackColumnReader<int32_t, date_t, ParquetIntToDate>>(reader, type_p, schema_p,
-		                                                                            file_idx_p, max_define, max_repeat);
+		return make_uniq<CallbackColumnReader<int32_t, date_t, ParquetIntToDate>>(reader, type_p, schema_p, file_idx_p,
+		                                                                          max_define, max_repeat);
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ:
-		return make_unique<CallbackColumnReader<int64_t, dtime_t, ParquetIntToTime>>(
-		    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+		if (schema_p.__isset.logicalType && schema_p.logicalType.__isset.TIME) {
+			if (schema_p.logicalType.TIME.unit.__isset.MILLIS) {
+				return make_uniq<CallbackColumnReader<int32_t, dtime_t, ParquetIntToTimeMs>>(
+				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+			} else if (schema_p.logicalType.TIME.unit.__isset.MICROS) {
+				return make_uniq<CallbackColumnReader<int64_t, dtime_t, ParquetIntToTime>>(
+				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+			} else if (schema_p.logicalType.TIME.unit.__isset.NANOS) {
+				return make_uniq<CallbackColumnReader<int64_t, dtime_t, ParquetIntToTimeNs>>(
+				    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::TIME_MICROS:
+				return make_uniq<CallbackColumnReader<int64_t, dtime_t, ParquetIntToTime>>(
+				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+			case ConvertedType::TIME_MILLIS:
+				return make_uniq<CallbackColumnReader<int32_t, dtime_t, ParquetIntToTimeMs>>(
+				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+			default:
+				break;
+			}
+		}
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::VARCHAR:
-		return make_unique<StringColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+		return make_uniq<StringColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::DECIMAL:
 		// we have to figure out what kind of int we need
 		switch (schema_p.type) {
@@ -1361,9 +1424,9 @@ unique_ptr<ColumnReader> ColumnReader::CreateReader(ParquetReader &reader, const
 		}
 		break;
 	case LogicalTypeId::UUID:
-		return make_unique<UUIDColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+		return make_uniq<UUIDColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	case LogicalTypeId::INTERVAL:
-		return make_unique<IntervalColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+		return make_uniq<IntervalColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
 	default:
 		break;
 	}