duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -52,7 +52,7 @@ using duckdb_parquet::format::Type;
 static unique_ptr<duckdb_apache::thrift::protocol::TProtocol>
 CreateThriftProtocol(Allocator &allocator, FileHandle &file_handle, FileOpener &opener, bool prefetch_mode) {
 	auto transport = make_shared<ThriftFileTransport>(allocator, file_handle, opener, prefetch_mode);
-	return make_unique<duckdb_apache::thrift::protocol::TCompactProtocolT<ThriftFileTransport>>(move(transport));
+	return make_unique<duckdb_apache::thrift::protocol::TCompactProtocolT<ThriftFileTransport>>(std::move(transport));
 }
 
 static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, FileHandle &file_handle,
@@ -87,7 +87,7 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 
 	auto metadata = make_unique<FileMetaData>();
 	metadata->read(proto.get());
-	return make_shared<ParquetFileMetadataCache>(move(metadata), current_time);
+	return make_shared<ParquetFileMetadataCache>(std::move(metadata), current_time);
 }
 
 LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele, bool binary_as_string) {
@@ -102,7 +102,15 @@ LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele, bool bi
 				return LogicalType::UUID;
 			}
 		} else if (s_ele.logicalType.__isset.TIMESTAMP) {
+			if (s_ele.logicalType.TIMESTAMP.isAdjustedToUTC) {
+				return LogicalType::TIMESTAMP_TZ;
+			}
 			return LogicalType::TIMESTAMP;
+		} else if (s_ele.logicalType.__isset.TIME) {
+			if (s_ele.logicalType.TIME.isAdjustedToUTC) {
+				return LogicalType::TIME_TZ;
+			}
+			return LogicalType::TIME;
 		}
 	}
 	if (s_ele.__isset.converted_type) {
@@ -201,7 +209,7 @@ LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele, bool bi
 		case ConvertedType::INTERVAL:
 			return LogicalType::INTERVAL;
 		case ConvertedType::JSON:
-			return LogicalType::JSON;
+			return LogicalType::VARCHAR;
 		case ConvertedType::MAP:
 		case ConvertedType::MAP_KEY_VALUE:
 		case ConvertedType::LIST:
@@ -249,13 +257,15 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(const FileMetaData
 	auto &s_ele = file_meta_data->schema[next_schema_idx];
 	auto this_idx = next_schema_idx;
 
-	if (s_ele.__isset.repetition_type) {
-		if (s_ele.repetition_type != FieldRepetitionType::REQUIRED) {
-			max_define++;
-		}
-		if (s_ele.repetition_type == FieldRepetitionType::REPEATED) {
-			max_repeat++;
-		}
+	auto repetition_type = FieldRepetitionType::REQUIRED;
+	if (s_ele.__isset.repetition_type && this_idx > 0) {
+		repetition_type = s_ele.repetition_type;
+	}
+	if (repetition_type != FieldRepetitionType::REQUIRED) {
+		max_define++;
+	}
+	if (repetition_type == FieldRepetitionType::REPEATED) {
+		max_repeat++;
 	}
 
 	if (!s_ele.__isset.type) { // inner node
@@ -274,7 +284,7 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(const FileMetaData
 			auto child_reader = CreateReaderRecursive(file_meta_data, depth + 1, max_define, max_repeat,
 			                                          next_schema_idx, next_file_idx);
 			child_types.push_back(make_pair(child_ele.name, child_reader->Type()));
-			child_readers.push_back(move(child_reader));
+			child_readers.push_back(std::move(child_reader));
 
 			c_idx++;
 		}
@@ -282,7 +292,7 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(const FileMetaData
 		unique_ptr<ColumnReader> result;
 		LogicalType result_type;
 
-		bool is_repeated = s_ele.repetition_type == FieldRepetitionType::REPEATED;
+		bool is_repeated = repetition_type == FieldRepetitionType::REPEATED;
 		bool is_list = s_ele.__isset.converted_type && s_ele.converted_type == ConvertedType::LIST;
 		bool is_map = s_ele.__isset.converted_type && s_ele.converted_type == ConvertedType::MAP;
 		bool is_map_kv = s_ele.__isset.converted_type && s_ele.converted_type == ConvertedType::MAP_KEY_VALUE;
@@ -301,27 +311,27 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(const FileMetaData
 			if (!is_repeated) {
 				throw IOException("MAP_KEY_VALUE needs to be repeated");
 			}
-			result_type = LogicalType::MAP(move(child_types[0].second), move(child_types[1].second));
+			result_type = LogicalType::MAP(std::move(child_types[0].second), std::move(child_types[1].second));
 
 			auto struct_reader =
 			    make_unique<StructColumnReader>(*this, ListType::GetChildType(result_type), s_ele, this_idx,
-			                                    max_define - 1, max_repeat - 1, move(child_readers));
+			                                    max_define - 1, max_repeat - 1, std::move(child_readers));
 			return make_unique<ListColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
-			                                     move(struct_reader));
+			                                     std::move(struct_reader));
 		}
 		if (child_types.size() > 1 || (!is_list && !is_map && !is_repeated)) {
-			result_type = LogicalType::STRUCT(move(child_types));
+			result_type = LogicalType::STRUCT(std::move(child_types));
 			result = make_unique<StructColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
-			                                         move(child_readers));
+			                                         std::move(child_readers));
 		} else {
 			// if we have a struct with only a single type, pull up
 			result_type = child_types[0].second;
-			result = move(child_readers[0]);
+			result = std::move(child_readers[0]);
 		}
 		if (is_repeated) {
 			result_type = LogicalType::LIST(result_type);
 			return make_unique<ListColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
-			                                     move(result));
+			                                     std::move(result));
 		}
 		return result;
 	} else { // leaf node
@@ -333,7 +343,18 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(const FileMetaData
 			    ColumnReader::CreateReader(*this, derived_type, s_ele, next_file_idx++, max_define, max_repeat);
 
 			return make_unique<ListColumnReader>(*this, list_type, s_ele, this_idx, max_define, max_repeat,
-			                                     move(element_reader));
+			                                     std::move(element_reader));
+		}
+
+		// if this is a hive partition col, we should not read it at all but instead do a constant reader.
+		if (parquet_options.hive_partitioning && hive_map && depth == 1) {
+			auto lookup = hive_map->find(s_ele.name);
+			if (lookup != hive_map->end()) {
+				Value val = Value(lookup->second);
+				return make_unique<GeneratedConstantColumnReader>(*this, LogicalType::VARCHAR, SchemaElement(),
+				                                                  next_file_idx++, max_define, max_repeat, val);
+				;
+			}
 		}
 
 		// TODO check return value of derive type or should we only do this on read()
@@ -347,19 +368,25 @@ unique_ptr<ColumnReader> ParquetReader::CreateReader(const duckdb_parquet::forma
 	idx_t next_schema_idx = 0;
 	idx_t next_file_idx = 0;
 
+	if (file_meta_data->schema.empty()) {
+		throw IOException("Parquet reader: no schema elements found");
+	}
+	if (file_meta_data->schema[0].num_children == 0) {
+		throw IOException("Parquet reader: root schema element has no children");
+	}
+
 	auto ret = CreateReaderRecursive(file_meta_data, 0, 0, 0, next_schema_idx, next_file_idx);
 	D_ASSERT(next_schema_idx == file_meta_data->schema.size() - 1);
 	D_ASSERT(file_meta_data->row_groups.empty() || next_file_idx == file_meta_data->row_groups[0].columns.size());
 
 	auto &root_struct_reader = (StructColumnReader &)*ret;
-
 	// add casts if required
 	for (auto &entry : cast_map) {
 		auto column_idx = entry.first;
 		auto &expected_type = entry.second;
-		auto child_reader = move(root_struct_reader.child_readers[column_idx]);
-		auto cast_reader = make_unique<CastColumnReader>(move(child_reader), expected_type);
-		root_struct_reader.child_readers[column_idx] = move(cast_reader);
+		auto child_reader = std::move(root_struct_reader.child_readers[column_idx]);
+		auto cast_reader = make_unique<CastColumnReader>(std::move(child_reader), expected_type);
+		root_struct_reader.child_readers[column_idx] = std::move(cast_reader);
 	}
 
 	if (parquet_options.filename) {
@@ -374,9 +401,7 @@ unique_ptr<ColumnReader> ParquetReader::CreateReader(const duckdb_parquet::forma
 	}
 
 	if (parquet_options.hive_partitioning) {
-		auto res = HivePartitioning::Parse(file_name);
-
-		for (auto &partition : res) {
+		for (auto &partition : *hive_map) {
 			Value val = Value(partition.second);
 			root_struct_reader.child_readers.push_back(make_unique<GeneratedConstantColumnReader>(
 			    *this, LogicalType::VARCHAR, SchemaElement(), next_file_idx, 0, 0, val));
@@ -432,10 +457,16 @@ void ParquetReader::InitializeSchema(const vector<string> &expected_names, const
 
 	// Add generated constant column for filename
 	if (parquet_options.hive_partitioning) {
-		auto partitions = HivePartitioning::Parse(file_name);
-		for (auto &part : partitions) {
-			return_types.emplace_back(LogicalType::VARCHAR);
-			names.emplace_back(part.first);
+		for (auto &part : *hive_map) {
+			// We need to lookup the hive col in the cols of the file to avoid duplicating columns that are both
+			// in the file and the hive path
+			auto lookup =
+			    std::find_if(child_types.begin(), child_types.end(),
+			                 [&part](const std::pair<std::string, LogicalType> &x) { return x.first == part.first; });
+			if (lookup == child_types.end()) {
+				return_types.emplace_back(LogicalType::VARCHAR);
+				names.emplace_back(part.first);
+			}
 		}
 	}
 
@@ -500,7 +531,7 @@ ParquetReader::ParquetReader(Allocator &allocator_p, unique_ptr<FileHandle> file
                              const vector<LogicalType> &expected_types_p, const string &initial_filename_p)
     : allocator(allocator_p) {
 	file_name = file_handle_p->path;
-	file_handle = move(file_handle_p);
+	file_handle = std::move(file_handle_p);
 	metadata = LoadMetadata(allocator, *file_handle, *file_opener);
 	vector<string> expected_names;
 	vector<column_t> expected_column_ids;
@@ -513,7 +544,7 @@ ParquetReader::ParquetReader(ClientContext &context_p, string file_name_p, const
     : allocator(BufferAllocator::Get(context_p)), file_opener(FileSystem::GetFileOpener(context_p)),
       parquet_options(parquet_options_p) {
 	auto &fs = FileSystem::GetFileSystem(context_p);
-	file_name = move(file_name_p);
+	file_name = std::move(file_name_p);
 	file_handle = fs.OpenFile(file_name, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
 	                          FileSystem::DEFAULT_COMPRESSION, file_opener);
 	if (!file_handle->CanSeek()) {
@@ -524,16 +555,21 @@ ParquetReader::ParquetReader(ClientContext &context_p, string file_name_p, const
 	// If object cached is disabled
 	// or if this file has cached metadata
 	// or if the cached version already expired
-	auto last_modify_time = fs.GetLastModifiedTime(*file_handle);
 	if (!ObjectCache::ObjectCacheEnabled(context_p)) {
 		metadata = LoadMetadata(allocator, *file_handle, *file_opener);
 	} else {
+		auto last_modify_time = fs.GetLastModifiedTime(*file_handle);
 		metadata = ObjectCache::GetObjectCache(context_p).Get<ParquetFileMetadataCache>(file_name);
 		if (!metadata || (last_modify_time + 10 >= metadata->read_time)) {
 			metadata = LoadMetadata(allocator, *file_handle, *file_opener);
 			ObjectCache::GetObjectCache(context_p).Put(file_name, metadata);
 		}
 	}
+
+	if (parquet_options.hive_partitioning) {
+		hive_map = make_unique<std::map<string, string>>(HivePartitioning::Parse(file_name));
+	}
+
 	InitializeSchema(expected_names, expected_types_p, column_ids, initial_filename_p);
 }
 
@@ -560,7 +596,7 @@ unique_ptr<BaseStatistics> ParquetReader::ReadStatistics(ParquetReader &reader,
 			return nullptr;
 		}
 		if (!column_stats) {
-			column_stats = move(chunk_stats);
+			column_stats = std::move(chunk_stats);
 		} else {
 			column_stats->Merge(*chunk_stats);
 		}
@@ -678,9 +714,9 @@ void ParquetReader::InitializeScan(ParquetReaderScanState &state, vector<column_
                                    vector<idx_t> groups_to_read, TableFilterSet *filters) {
 	state.current_group = -1;
 	state.finished = false;
-	state.column_ids = column_id_map.empty() ? move(column_ids) : column_id_map;
+	state.column_ids = column_id_map.empty() ? std::move(column_ids) : column_id_map;
 	state.group_offset = 0;
-	state.group_idx_list = move(groups_to_read);
+	state.group_idx_list = std::move(groups_to_read);
 	state.filters = filters;
 	state.sel.Initialize(STANDARD_VECTOR_SIZE);
 
@@ -700,11 +736,35 @@ void ParquetReader::InitializeScan(ParquetReaderScanState &state, vector<column_
 
 	state.thrift_file_proto = CreateThriftProtocol(allocator, *state.file_handle, *file_opener, state.prefetch_mode);
 	state.root_reader = CreateReader(GetFileMetadata());
+	if (parquet_options.union_by_name) {
+		RearrangeChildReaders(state.root_reader, state.column_ids);
+	}
 
 	state.define_buf.resize(allocator, STANDARD_VECTOR_SIZE);
 	state.repeat_buf.resize(allocator, STANDARD_VECTOR_SIZE);
 }
 
+void ParquetReader::RearrangeChildReaders(unique_ptr<duckdb::ColumnReader> &root_reader, vector<column_t> &column_ids) {
+	auto &root_struct_reader = (StructColumnReader &)*root_reader;
+	unordered_map<idx_t, idx_t> reverse_union_idx;
+
+	for (idx_t col = 0; col < union_idx_map.size(); ++col) {
+		auto child_reader = std::move(root_struct_reader.child_readers[col]);
+		auto cast_reader = make_unique<CastColumnReader>(std::move(child_reader), union_col_types[union_idx_map[col]]);
+		root_struct_reader.child_readers[col] = std::move(cast_reader);
+		reverse_union_idx[union_idx_map[col]] = col;
+	}
+
+	vector<bool> column_id_nulls(column_ids.size(), true);
+	for (idx_t col = 0; col < column_ids.size(); ++col) {
+		auto find = reverse_union_idx.find(column_ids[col]);
+		if (find != reverse_union_idx.end()) {
+			column_ids[col] = find->second;
+			column_id_nulls[col] = false;
+		}
+	}
+	union_null_cols = std::move(column_id_nulls);
+}
 void FilterIsNull(Vector &v, parquet_filter_t &filter_mask, idx_t count) {
 	if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		auto &mask = ConstantVector::Validity(v);
@@ -898,6 +958,8 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		return false;
 	}
 
+	D_ASSERT(union_null_cols.size() >= result.ColumnCount());
+
 	// see if we have to switch to the next row group in the parquet file
 	if (state.current_group < 0 || (int64_t)state.group_offset >= GetGroup(state).num_rows) {
 		state.current_group++;
@@ -915,7 +977,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		uint64_t to_scan_compressed_bytes = 0;
 		for (idx_t out_col_idx = 0; out_col_idx < result.ColumnCount(); out_col_idx++) {
 			// this is a special case where we are not interested in the actual contents of the file
-			if (IsRowIdColumnId(state.column_ids[out_col_idx])) {
+			if (IsRowIdColumnId(state.column_ids[out_col_idx]) || union_null_cols[out_col_idx]) {
 				continue;
 			}
 
@@ -956,7 +1018,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				// Prefetch column-wise
 				for (idx_t out_col_idx = 0; out_col_idx < result.ColumnCount(); out_col_idx++) {
 
-					if (IsRowIdColumnId(state.column_ids[out_col_idx])) {
+					if (IsRowIdColumnId(state.column_ids[out_col_idx]) || union_null_cols[out_col_idx]) {
 						continue;
 					}
 
@@ -1007,6 +1069,10 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 	if (state.filters) {
 		vector<bool> need_to_read(result.ColumnCount(), true);
 
+		for (idx_t col = 0; col < need_to_read.size(); ++col) {
+			need_to_read[col] = need_to_read[col] && !union_null_cols[col];
+		}
+
 		// first load the columns that are used in filters
 		for (auto &filter_col : state.filters->filters) {
 			auto file_col_idx = state.column_ids[filter_col.first];
@@ -1058,6 +1124,9 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				result.data[out_col_idx].Reference(constant_42);
 				continue;
 			}
+			if (union_null_cols[out_col_idx]) {
+				continue;
+			}
 
 			auto rows_read = root_reader->GetChildReader(file_col_idx)
 			                     ->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result.data[out_col_idx]);

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

@@ -38,7 +38,7 @@ static unique_ptr<BaseStatistics> CreateNumericStats(const LogicalType &type,
 	} else {
 		stats->max = Value(type);
 	}
-	return move(stats);
+	return std::move(stats);
 }
 
 Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
@@ -153,11 +153,15 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		}
 		return Value::DATE(date_t(Load<int32_t>((data_ptr_t)stats.c_str())));
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ: {
 		if (stats.size() != sizeof(int64_t)) {
 			throw InternalException("Incorrect stats size for type TIME");
 		}
-		return Value::TIME(dtime_t(Load<int64_t>((data_ptr_t)stats.c_str())));
-	case LogicalTypeId::TIMESTAMP: {
+		auto time = dtime_t(Load<int64_t>((data_ptr_t)stats.c_str()));
+		return Value::TIME(time);
+	}
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ: {
 		if (schema_ele.type == Type::INT96) {
 			if (stats.size() != sizeof(Int96)) {
 				throw InternalException("Incorrect stats size for type TIMESTAMP");
@@ -241,7 +245,7 @@ unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(con
 		}
 		string_stats->has_unicode = true; // we dont know better
 		string_stats->max_string_length = NumericLimits<uint32_t>::Maximum();
-		row_group_stats = move(string_stats);
+		row_group_stats = std::move(string_stats);
 		break;
 	}
 	default:

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

@@ -69,9 +69,9 @@ Type::type ParquetWriter::DuckDBTypeToParquetType(const LogicalType &duckdb_type
 	case LogicalTypeId::HUGEINT:
 		return Type::DOUBLE;
 	case LogicalTypeId::ENUM:
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::BLOB:
+	case LogicalTypeId::VARCHAR:
+	case LogicalTypeId::BIT:
 		return Type::BYTE_ARRAY;
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ:
@@ -150,6 +150,7 @@ void ParquetWriter::SetSchemaProperties(const LogicalType &duckdb_type,
 	case LogicalTypeId::TIME:
 		schema_ele.converted_type = ConvertedType::TIME_MICROS;
 		schema_ele.__isset.converted_type = true;
+		schema_ele.__isset.logicalType = true;
 		schema_ele.logicalType.__isset.TIME = true;
 		schema_ele.logicalType.TIME.isAdjustedToUTC = (duckdb_type.id() == LogicalTypeId::TIME_TZ);
 		schema_ele.logicalType.TIME.unit.__isset.MICROS = true;
@@ -175,7 +176,6 @@ void ParquetWriter::SetSchemaProperties(const LogicalType &duckdb_type,
 		break;
 	case LogicalTypeId::ENUM:
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
 		schema_ele.converted_type = ConvertedType::UTF8;
 		schema_ele.__isset.converted_type = true;
 		break;
@@ -212,9 +212,22 @@ void ParquetWriter::SetSchemaProperties(const LogicalType &duckdb_type,
 	}
 }
 
+void VerifyUniqueNames(const vector<string> &names) {
+#ifdef DEBUG
+	unordered_set<string> name_set;
+	name_set.reserve(names.size());
+	for (auto &column : names) {
+		auto res = name_set.insert(column);
+		D_ASSERT(res.second == true);
+	}
+	// If there would be duplicates, these sizes would differ
+	D_ASSERT(name_set.size() == names.size());
+#endif
+}
+
 ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, FileOpener *file_opener_p, vector<LogicalType> types_p,
                              vector<string> names_p, CompressionCodec::type codec)
-    : file_name(move(file_name_p)), sql_types(move(types_p)), column_names(move(names_p)), codec(codec) {
+    : file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec) {
 	// initialize the file writer
 	writer = make_unique<BufferedFileWriter>(
 	    fs, file_name.c_str(), FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW, file_opener_p);
@@ -238,10 +251,13 @@ ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, FileOpener *fil
 	file_meta_data.schema[0].repetition_type = duckdb_parquet::format::FieldRepetitionType::REQUIRED;
 	file_meta_data.schema[0].__isset.repetition_type = true;
 
+	auto &unique_names = column_names;
+	VerifyUniqueNames(unique_names);
+
 	vector<string> schema_path;
 	for (idx_t i = 0; i < sql_types.size(); i++) {
 		column_writers.push_back(ColumnWriter::CreateWriterRecursive(file_meta_data.schema, *this, sql_types[i],
-		                                                             column_names[i], schema_path));
+		                                                             unique_names[i], schema_path));
 	}
 }
 
@@ -274,14 +290,14 @@ void ParquetWriter::Flush(ColumnDataCollection &buffer) {
 		for (auto &chunk : buffer.Chunks()) {
 			col_writer->Write(*write_state, chunk.data[col_idx], chunk.size());
 		}
-		states.push_back(move(write_state));
+		states.push_back(std::move(write_state));
 	}
 
 	lock_guard<mutex> glock(lock);
 	row_group.file_offset = writer->GetTotalWritten();
 	for (idx_t col_idx = 0; col_idx < buffer.ColumnCount(); col_idx++) {
 		const auto &col_writer = column_writers[col_idx];
-		auto write_state = move(states[col_idx]);
+		auto write_state = std::move(states[col_idx]);
 		col_writer->FinalizeWrite(*write_state);
 	}
 

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

@@ -156,7 +156,7 @@ void ZstdStreamWrapper::Close() {
 class ZStdFile : public CompressedFile {
 public:
 	ZStdFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
-	    : CompressedFile(zstd_fs, move(child_handle_p), path) {
+	    : CompressedFile(zstd_fs, std::move(child_handle_p), path) {
 		Initialize(write);
 	}
 
@@ -165,7 +165,7 @@ public:
 
 unique_ptr<FileHandle> ZStdFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
 	auto path = handle->path;
-	return make_unique<ZStdFile>(move(handle), path, write);
+	return make_unique<ZStdFile>(std::move(handle), path, write);
 }
 
 unique_ptr<StreamWrapper> ZStdFileSystem::CreateStream() {