duckdb 0.7.2-dev3441.0 → 0.7.2-dev3546.0

package/src/duckdb/src/common/virtual_file_system.cpp

@@ -15,6 +15,10 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 	if (compression == FileCompressionType::AUTO_DETECT) {
 		// auto detect compression settings based on file name
 		auto lower_path = StringUtil::Lower(path);
+		if (StringUtil::EndsWith(lower_path, ".tmp")) {
+			// strip .tmp
+			lower_path = lower_path.substr(0, lower_path.length() - 4);
+		}
 		if (StringUtil::EndsWith(lower_path, ".gz")) {
 			compression = FileCompressionType::GZIP;
 		} else if (StringUtil::EndsWith(lower_path, ".zst")) {

package/src/duckdb/src/common/windows_util.cpp

@@ -11,7 +11,7 @@ std::wstring WindowsUtil::UTF8ToUnicode(const char *input) {
 	if (result_size == 0) {
 		throw IOException("Failure in MultiByteToWideChar");
 	}
-	auto buffer = unique_ptr<wchar_t[]>(new wchar_t[result_size]);
+	auto buffer = make_unsafe_array<wchar_t>(result_size);
 	result_size = MultiByteToWideChar(CP_UTF8, 0, input, -1, buffer.get(), result_size);
 	if (result_size == 0) {
 		throw IOException("Failure in MultiByteToWideChar");
@@ -26,7 +26,7 @@ static string WideCharToMultiByteWrapper(LPCWSTR input, uint32_t code_page) {
 	if (result_size == 0) {
 		throw IOException("Failure in WideCharToMultiByte");
 	}
-	auto buffer = unique_ptr<char[]>(new char[result_size]);
+	auto buffer = make_unsafe_array<char>(result_size);
 	result_size = WideCharToMultiByte(code_page, 0, input, -1, buffer.get(), result_size, 0, 0);
 	if (result_size == 0) {
 		throw IOException("Failure in WideCharToMultiByte");

package/src/duckdb/src/core_functions/aggregate/distributive/string_agg.cpp

@@ -131,18 +131,21 @@ unique_ptr<FunctionData> StringAggBind(ClientContext &context, AggregateFunction
 		throw BinderException("Separator argument to StringAgg must be a constant");
 	}
 	auto separator_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
+	string separator_string = ",";
 	if (separator_val.IsNull()) {
 		arguments[0] = make_uniq<BoundConstantExpression>(Value(LogicalType::VARCHAR));
+	} else {
+		separator_string = separator_val.ToString();
 	}
 	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	return make_uniq<StringAggBindData>(separator_val.ToString());
+	return make_uniq<StringAggBindData>(std::move(separator_string));
 }
 
 static void StringAggSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
                                const AggregateFunction &function) {
 	D_ASSERT(bind_data_p);
-	auto bind_data = (StringAggBindData *)bind_data_p;
-	writer.WriteString(bind_data->sep);
+	auto bind_data = bind_data_p->Cast<StringAggBindData>();
+	writer.WriteString(bind_data.sep);
 }
 
 unique_ptr<FunctionData> StringAggDeserialize(ClientContext &context, FieldReader &reader,

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -179,7 +179,7 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 
 	// state_buffer holds the state for each list of this chunk
 	idx_t size = aggr.function.state_size();
-	auto state_buffer = unique_ptr<data_t[]>(new data_t[size * count]);
+	auto state_buffer = make_unsafe_array<data_t>(size * count);
 
 	// state vector for initialize and finalize
 	StateVector state_vector(count, info.aggr_expr->Copy());
@@ -344,19 +344,16 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 }
 
 static void ListAggregateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
-	D_ASSERT(args.ColumnCount() == 2);
+	D_ASSERT(args.ColumnCount() >= 2);
 	ListAggregatesFunction<AggregateFunctor, true>(args, state, result);
 }
 
 static void ListDistinctFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
 	D_ASSERT(args.ColumnCount() == 1);
 	ListAggregatesFunction<DistinctFunctor>(args, state, result);
 }
 
 static void ListUniqueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
 	D_ASSERT(args.ColumnCount() == 1);
 	ListAggregatesFunction<UniqueFunctor>(args, state, result);
 }

package/src/duckdb/src/core_functions/scalar/string/printf.cpp

@@ -94,7 +94,7 @@ static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 
 		// now gather all the format arguments
 		vector<duckdb_fmt::basic_format_arg<CTX>> format_args;
-		vector<unique_ptr<data_t[]>> string_args;
+		vector<unsafe_array_ptr<data_t>> string_args;
 
 		for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
 			auto &col = args.data[col_idx];

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -390,7 +390,7 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(AggregateHTAppendSta
 	}
 	TupleDataCollection::ToUnifiedFormat(state.chunk_state, state.group_chunk);
 	if (!state.group_data) {
-		state.group_data = unique_ptr<UnifiedVectorFormat[]>(new UnifiedVectorFormat[state.group_chunk.ColumnCount()]);
+		state.group_data = make_unsafe_array<UnifiedVectorFormat>(state.group_chunk.ColumnCount());
 	}
 	TupleDataCollection::GetVectorData(state.chunk_state, state.group_data.get());
 

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -142,7 +142,7 @@ static idx_t FilterNullValues(UnifiedVectorFormat &vdata, const SelectionVector
 	return result_count;
 }
 
-idx_t JoinHashTable::PrepareKeys(DataChunk &keys, unique_ptr<UnifiedVectorFormat[]> &key_data,
+idx_t JoinHashTable::PrepareKeys(DataChunk &keys, unsafe_array_ptr<UnifiedVectorFormat> &key_data,
                                  const SelectionVector *&current_sel, SelectionVector &sel, bool build_side) {
 	key_data = keys.ToUnifiedFormat();
 
@@ -197,7 +197,7 @@ void JoinHashTable::Build(PartitionedTupleDataAppendState &append_state, DataChu
 	}
 
 	// prepare the keys for processing
-	unique_ptr<UnifiedVectorFormat[]> key_data;
+	unsafe_array_ptr<UnifiedVectorFormat> key_data;
 	const SelectionVector *current_sel;
 	SelectionVector sel(STANDARD_VECTOR_SIZE);
 	idx_t added_count = PrepareKeys(keys, key_data, current_sel, sel, true);
@@ -332,7 +332,7 @@ unique_ptr<ScanStructure> JoinHashTable::InitializeScanStructure(DataChunk &keys
 	auto ss = make_uniq<ScanStructure>(*this);
 
 	if (join_type != JoinType::INNER) {
-		ss->found_match = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
+		ss->found_match = make_unsafe_array<bool>(STANDARD_VECTOR_SIZE);
 		memset(ss->found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
 	}
 

package/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp

@@ -39,7 +39,7 @@ struct AggregateState {
 		for (auto &aggregate : aggregate_expressions) {
 			D_ASSERT(aggregate->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
 			auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-			auto state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
+			auto state = make_unsafe_array<data_t>(aggr.function.state_size());
 			aggr.function.initialize(state.get());
 			aggregates.push_back(std::move(state));
 			bind_data.push_back(aggr.bind_info.get());
@@ -69,7 +69,7 @@ struct AggregateState {
 	}
 
 	//! The aggregate values
-	vector<unique_ptr<data_t[]>> aggregates;
+	vector<unsafe_array_ptr<data_t>> aggregates;
 	//! The bind data
 	vector<FunctionData *> bind_data;
 	//! The destructors

package/src/duckdb/src/execution/operator/join/outer_join_marker.cpp

@@ -10,7 +10,7 @@ void OuterJoinMarker::Initialize(idx_t count_p) {
 		return;
 	}
 	this->count = count_p;
-	found_match = unique_ptr<bool[]>(new bool[count]);
+	found_match = make_unsafe_array<bool>(count);
 	Reset();
 }
 

package/src/duckdb/src/execution/operator/join/perfect_hash_join_executor.cpp

@@ -25,7 +25,7 @@ bool PerfectHashJoinExecutor::BuildPerfectHashTable(LogicalType &key_type) {
 	}
 
 	// and for duplicate_checking
-	bitmap_build_idx = unique_ptr<bool[]>(new bool[build_size]);
+	bitmap_build_idx = make_unsafe_array<bool>(build_size);
 	memset(bitmap_build_idx.get(), 0, sizeof(bool) * build_size); // set false
 
 	// Now fill columns with build data

package/src/duckdb/src/execution/operator/join/physical_range_join.cpp

@@ -72,7 +72,7 @@ void PhysicalRangeJoin::GlobalSortedTable::Combine(LocalSortedTable &ltable) {
 }
 
 void PhysicalRangeJoin::GlobalSortedTable::IntializeMatches() {
-	found_match = unique_ptr<bool[]>(new bool[Count()]);
+	found_match = make_unsafe_array<bool>(Count());
 	memset(found_match.get(), 0, sizeof(bool) * Count());
 }
 

package/src/duckdb/src/execution/operator/persistent/base_csv_reader.cpp

@@ -34,7 +34,7 @@ string BaseCSVReader::GetLineNumberStr(idx_t line_error, bool is_line_estimated,
 
 BaseCSVReader::BaseCSVReader(ClientContext &context_p, BufferedCSVReaderOptions options_p,
                              const vector<LogicalType> &requested_types)
-    : context(context_p), fs(FileSystem::GetFileSystem(context)), allocator(Allocator::Get(context)),
+    : context(context_p), fs(FileSystem::GetFileSystem(context)), allocator(BufferAllocator::Get(context)),
       options(std::move(options_p)) {
 }
 
@@ -42,12 +42,7 @@ BaseCSVReader::~BaseCSVReader() {
 }
 
 unique_ptr<CSVFileHandle> BaseCSVReader::OpenCSV(const BufferedCSVReaderOptions &options_p) {
-	auto file_handle = fs.OpenFile(options_p.file_path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK,
-	                               options_p.compression);
-	if (file_handle->CanSeek()) {
-		file_handle->Reset();
-	}
-	return make_uniq<CSVFileHandle>(std::move(file_handle));
+	return CSVFileHandle::OpenFile(fs, allocator, options_p.file_path, options_p.compression, true);
 }
 
 void BaseCSVReader::InitParseChunk(idx_t num_cols) {

package/src/duckdb/src/execution/operator/persistent/buffered_csv_reader.cpp

@@ -239,18 +239,13 @@ void BufferedCSVReader::Initialize(const vector<LogicalType> &requested_types) {
 		if (return_types.empty()) {
 			throw InvalidInputException("Failed to detect column types from CSV: is the file a valid CSV file?");
 		}
-		if (cached_chunks.empty()) {
-			JumpToBeginning(options.skip_rows, options.header);
-		}
+		JumpToBeginning(options.skip_rows, options.header);
 	} else {
 		return_types = requested_types;
 		ResetBuffer();
 		SkipRowsAndReadHeader(options.skip_rows, options.header);
 	}
 	InitParseChunk(return_types.size());
-	// we only need reset support during the automatic CSV type detection
-	// since reset support might require caching (in the case of streams), we disable it for the remainder
-	file_handle->DisableReset();
 }
 
 void BufferedCSVReader::ResetBuffer() {
@@ -262,13 +257,7 @@ void BufferedCSVReader::ResetBuffer() {
 }
 
 void BufferedCSVReader::ResetStream() {
-	if (!file_handle->CanSeek()) {
-		// seeking to the beginning appears to not be supported in all compiler/os-scenarios,
-		// so we have to create a new stream source here for now
-		file_handle->Reset();
-	} else {
-		file_handle->Seek(0);
-	}
+	file_handle->Reset();
 	linenr = 0;
 	linenr_estimated = false;
 	bytes_per_line_avg = 0;
@@ -332,7 +321,7 @@ bool BufferedCSVReader::JumpToNextSample() {
 
 	// if we deal with any other sources than plaintext files, jumping_samples can be tricky. In that case
 	// we just read x continuous chunks from the stream TODO: make jumps possible for zipfiles.
-	if (!file_handle->PlainFileSource() || !jumping_samples) {
+	if (!file_handle->OnDiskFile() || !jumping_samples) {
 		sample_chunk_idx++;
 		return true;
 	}
@@ -802,21 +791,6 @@ vector<LogicalType> BufferedCSVReader::RefineTypeDetection(const vector<LogicalT
 					}
 				}
 			}
-
-			if (!jumping_samples) {
-				if ((sample_chunk_idx)*options.sample_chunk_size <= options.buffer_size) {
-					// cache parse chunk
-					// create a new chunk and fill it with the remainder
-					auto chunk = make_uniq<DataChunk>();
-					auto parse_chunk_types = parse_chunk.GetTypes();
-					chunk->Move(parse_chunk);
-					cached_chunks.push(std::move(chunk));
-				} else {
-					while (!cached_chunks.empty()) {
-						cached_chunks.pop();
-					}
-				}
-			}
 		}
 
 		// set sql types
@@ -1445,7 +1419,7 @@ bool BufferedCSVReader::ReadBuffer(idx_t &start, idx_t &line_start) {
 		                            GetLineNumberStr(linenr, linenr_estimated));
 	}
 
-	buffer = unique_ptr<char[]>(new char[buffer_read_size + remaining + 1]);
+	buffer = make_unsafe_array<char>(buffer_read_size + remaining + 1);
 	buffer_size = remaining + buffer_read_size;
 	if (remaining > 0) {
 		// remaining from last buffer: copy it here
@@ -1474,17 +1448,6 @@ bool BufferedCSVReader::ReadBuffer(idx_t &start, idx_t &line_start) {
 }
 
 void BufferedCSVReader::ParseCSV(DataChunk &insert_chunk) {
-	// if no auto-detect or auto-detect with jumping samples, we have nothing cached and start from the beginning
-	if (cached_chunks.empty()) {
-		cached_buffers.clear();
-	} else {
-		auto &chunk = cached_chunks.front();
-		parse_chunk.Move(*chunk);
-		cached_chunks.pop();
-		Flush(insert_chunk);
-		return;
-	}
-
 	string error_message;
 	if (!TryParseCSV(ParserMode::PARSING, insert_chunk, error_message)) {
 		throw InvalidInputException(error_message);

package/src/duckdb/src/execution/operator/persistent/csv_file_handle.cpp

@@ -0,0 +1,158 @@
+#include "duckdb/execution/operator/persistent/csv_file_handle.hpp"
+
+namespace duckdb {
+
+CSVFileHandle::CSVFileHandle(FileSystem &fs, Allocator &allocator, unique_ptr<FileHandle> file_handle_p,
+                             const string &path_p, FileCompressionType compression, bool enable_reset)
+    : fs(fs), allocator(allocator), file_handle(std::move(file_handle_p)), path(path_p), compression(compression),
+      reset_enabled(enable_reset) {
+	can_seek = file_handle->CanSeek();
+	on_disk_file = file_handle->OnDiskFile();
+	file_size = file_handle->GetFileSize();
+}
+
+unique_ptr<FileHandle> CSVFileHandle::OpenFileHandle(FileSystem &fs, Allocator &allocator, const string &path,
+                                                     FileCompressionType compression) {
+	auto file_handle = fs.OpenFile(path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK, compression);
+	if (file_handle->CanSeek()) {
+		file_handle->Reset();
+	}
+	return file_handle;
+}
+
+unique_ptr<CSVFileHandle> CSVFileHandle::OpenFile(FileSystem &fs, Allocator &allocator, const string &path,
+                                                  FileCompressionType compression, bool enable_reset) {
+	auto file_handle = CSVFileHandle::OpenFileHandle(fs, allocator, path, compression);
+	return make_uniq<CSVFileHandle>(fs, allocator, std::move(file_handle), path, compression, enable_reset);
+}
+
+bool CSVFileHandle::CanSeek() {
+	return can_seek;
+}
+
+void CSVFileHandle::Seek(idx_t position) {
+	if (!can_seek) {
+		throw InternalException("Cannot seek in this file");
+	}
+	file_handle->Seek(position);
+}
+
+idx_t CSVFileHandle::SeekPosition() {
+	if (!can_seek) {
+		throw InternalException("Cannot seek in this file");
+	}
+	return file_handle->SeekPosition();
+}
+
+void CSVFileHandle::Reset() {
+	requested_bytes = 0;
+	read_position = 0;
+	if (can_seek) {
+		// we can seek - reset the file handle
+		file_handle->Reset();
+	} else if (on_disk_file) {
+		// we cannot seek but it is an on-disk file - re-open the file
+		file_handle = CSVFileHandle::OpenFileHandle(fs, allocator, path, compression);
+	} else {
+		if (!reset_enabled) {
+			throw InternalException("Reset called but reset is not enabled for this CSV Handle");
+		}
+		read_position = 0;
+	}
+}
+bool CSVFileHandle::OnDiskFile() {
+	return on_disk_file;
+}
+
+idx_t CSVFileHandle::FileSize() {
+	return file_size;
+}
+
+bool CSVFileHandle::FinishedReading() {
+	return requested_bytes >= file_size;
+}
+
+idx_t CSVFileHandle::Read(void *buffer, idx_t nr_bytes) {
+	requested_bytes += nr_bytes;
+	if (on_disk_file || can_seek) {
+		// if this is a plain file source OR we can seek we are not caching anything
+		return file_handle->Read(buffer, nr_bytes);
+	}
+	// not a plain file source: we need to do some bookkeeping around the reset functionality
+	idx_t result_offset = 0;
+	if (read_position < buffer_size) {
+		// we need to read from our cached buffer
+		auto buffer_read_count = MinValue<idx_t>(nr_bytes, buffer_size - read_position);
+		memcpy(buffer, cached_buffer.get() + read_position, buffer_read_count);
+		result_offset += buffer_read_count;
+		read_position += buffer_read_count;
+		if (result_offset == nr_bytes) {
+			return nr_bytes;
+		}
+	} else if (!reset_enabled && cached_buffer.IsSet()) {
+		// reset is disabled, but we still have cached data
+		// we can remove any cached data
+		cached_buffer.Reset();
+		buffer_size = 0;
+		buffer_capacity = 0;
+		read_position = 0;
+	}
+	// we have data left to read from the file
+	// read directly into the buffer
+	auto bytes_read = file_handle->Read((char *)buffer + result_offset, nr_bytes - result_offset);
+	file_size = file_handle->GetFileSize();
+	read_position += bytes_read;
+	if (reset_enabled) {
+		// if reset caching is enabled, we need to cache the bytes that we have read
+		if (buffer_size + bytes_read >= buffer_capacity) {
+			// no space; first enlarge the buffer
+			buffer_capacity = MaxValue<idx_t>(NextPowerOfTwo(buffer_size + bytes_read), buffer_capacity * 2);
+
+			auto new_buffer = allocator.Allocate(buffer_capacity);
+			if (buffer_size > 0) {
+				memcpy(new_buffer.get(), cached_buffer.get(), buffer_size);
+			}
+			cached_buffer = std::move(new_buffer);
+		}
+		memcpy(cached_buffer.get() + buffer_size, (char *)buffer + result_offset, bytes_read);
+		buffer_size += bytes_read;
+	}
+
+	return result_offset + bytes_read;
+}
+
+string CSVFileHandle::ReadLine() {
+	bool carriage_return = false;
+	string result;
+	char buffer[1];
+	while (true) {
+		idx_t bytes_read = Read(buffer, 1);
+		if (bytes_read == 0) {
+			return result;
+		}
+		if (carriage_return) {
+			if (buffer[0] != '\n') {
+				if (!file_handle->CanSeek()) {
+					throw BinderException(
+					    "Carriage return newlines not supported when reading CSV files in which we cannot seek");
+				}
+				file_handle->Seek(file_handle->SeekPosition() - 1);
+				return result;
+			}
+		}
+		if (buffer[0] == '\n') {
+			return result;
+		}
+		if (buffer[0] != '\r') {
+			result += buffer[0];
+		} else {
+			carriage_return = true;
+		}
+	}
+}
+
+void CSVFileHandle::DisableReset() {
+	this->reset_enabled = false;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/operator/projection/physical_pivot.cpp

@@ -19,7 +19,7 @@ PhysicalPivot::PhysicalPivot(vector<LogicalType> types_p, unique_ptr<PhysicalOpe
 	for (auto &aggr_expr : bound_pivot.aggregates) {
 		auto &aggr = (BoundAggregateExpression &)*aggr_expr;
 		// for each aggregate, initialize an empty aggregate state and finalize it immediately
-		auto state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
+		auto state = make_unsafe_array<data_t>(aggr.function.state_size());
 		aggr.function.initialize(state.get());
 		Vector state_vector(Value::POINTER((uintptr_t)state.get()));
 		Vector result_vector(aggr_expr->return_type);

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -7,9 +7,9 @@
 
 namespace duckdb {
 
-PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality)
+PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info_p, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TYPE, {LogicalType::BIGINT}, estimated_cardinality),
-      info(std::move(info)) {
+      info(std::move(info_p)) {
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp

@@ -23,11 +23,11 @@ PerfectAggregateHashTable::PerfectAggregateHashTable(ClientContext &context, All
 	tuple_size = layout.GetRowWidth();
 
 	// allocate and null initialize the data
-	owned_data = unique_ptr<data_t[]>(new data_t[tuple_size * total_groups]);
+	owned_data = make_unsafe_array<data_t>(tuple_size * total_groups);
 	data = owned_data.get();
 
 	// set up the empty payloads for every tuple, and initialize the "occupied" flag to false
-	group_is_set = unique_ptr<bool[]>(new bool[total_groups]);
+	group_is_set = make_unsafe_array<bool>(total_groups);
 	memset(group_is_set.get(), 0, total_groups * sizeof(bool));
 
 	// initialize the hash table for each entry

package/src/duckdb/src/execution/radix_partitioned_hashtable.cpp

@@ -334,7 +334,7 @@ public:
 	//! The current position to scan the HT for output tuples
 	idx_t ht_index;
 	//! The set of aggregate scan states
-	unique_ptr<TupleDataParallelScanState[]> ht_scan_states;
+	unsafe_array_ptr<TupleDataParallelScanState> ht_scan_states;
 	atomic<bool> initialized;
 	atomic<bool> finished;
 };
@@ -404,7 +404,7 @@ SourceResultType RadixPartitionedHashTable::GetData(ExecutionContext &context, D
 		for (idx_t i = 0; i < op.aggregates.size(); i++) {
 			D_ASSERT(op.aggregates[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
 			auto &aggr = op.aggregates[i]->Cast<BoundAggregateExpression>();
-			auto aggr_state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
+			auto aggr_state = make_unsafe_array<data_t>(aggr.function.state_size());
 			aggr.function.initialize(aggr_state.get());
 
 			AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
@@ -433,8 +433,7 @@ SourceResultType RadixPartitionedHashTable::GetData(ExecutionContext &context, D
 		lock_guard<mutex> l(state.lock);
 		if (!state.initialized) {
 			auto &finalized_hts = gstate.finalized_hts;
-			state.ht_scan_states =
-			    unique_ptr<TupleDataParallelScanState[]>(new TupleDataParallelScanState[finalized_hts.size()]);
+			state.ht_scan_states = make_unsafe_array<TupleDataParallelScanState>(finalized_hts.size());
 
 			const auto &layout = gstate.finalized_hts[0]->GetDataCollection().GetLayout();
 			vector<column_t> column_ids;

package/src/duckdb/src/execution/window_segment_tree.cpp

@@ -309,7 +309,7 @@ void WindowSegmentTree::ConstructTree() {
 		level_nodes = (level_nodes + (TREE_FANOUT - 1)) / TREE_FANOUT;
 		internal_nodes += level_nodes;
 	} while (level_nodes > 1);
-	levels_flat_native = unique_ptr<data_t[]>(new data_t[internal_nodes * state.size()]);
+	levels_flat_native = make_unsafe_array<data_t>(internal_nodes * state.size());
 	levels_flat_start.push_back(0);
 
 	idx_t levels_flat_offset = 0;

package/src/duckdb/src/function/macro_function.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/scalar_macro_function.hpp"
+#include "duckdb/function/table_macro_function.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
@@ -91,4 +92,46 @@ string MacroFunction::ToSQL(const string &schema, const string &name) const {
 	return StringUtil::Format("CREATE MACRO %s.%s(%s) AS ", schema, name, StringUtil::Join(param_strings, ", "));
 }
 
+void MacroFunction::Serialize(Serializer &main_serializer) const {
+	FieldWriter writer(main_serializer);
+	writer.WriteField(type);
+	writer.WriteSerializableList(parameters);
+	writer.WriteField<uint32_t>((uint32_t)default_parameters.size());
+	auto &serializer = writer.GetSerializer();
+	for (auto &kv : default_parameters) {
+		serializer.WriteString(kv.first);
+		kv.second->Serialize(serializer);
+	}
+	SerializeInternal(writer);
+	writer.Finalize();
+}
+
+unique_ptr<MacroFunction> MacroFunction::Deserialize(Deserializer &main_source) {
+	FieldReader reader(main_source);
+	auto type = reader.ReadRequired<MacroType>();
+	auto parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
+	auto default_param_count = reader.ReadRequired<uint32_t>();
+	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
+	auto &source = reader.GetSource();
+	for (idx_t i = 0; i < default_param_count; i++) {
+		auto name = source.Read<string>();
+		default_parameters[name] = ParsedExpression::Deserialize(source);
+	}
+	unique_ptr<MacroFunction> result;
+	switch (type) {
+	case MacroType::SCALAR_MACRO:
+		result = ScalarMacroFunction::Deserialize(reader);
+		break;
+	case MacroType::TABLE_MACRO:
+		result = TableMacroFunction::Deserialize(reader);
+		break;
+	default:
+		throw InternalException("Cannot deserialize macro type");
+	}
+	result->parameters = std::move(parameters);
+	result->default_parameters = std::move(default_parameters);
+	reader.Finalize();
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -139,7 +139,7 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 		auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
 		                          FileSystem::DEFAULT_COMPRESSION);
 		auto fsize = fs.GetFileSize(*handle);
-		auto buffer = unique_ptr<char[]>(new char[fsize]);
+		auto buffer = make_unsafe_array<char>(fsize);
 		fs.Read(*handle, buffer.get(), fsize);
 		auto query = string(buffer.get(), fsize);
 		// Replace the placeholder with the path provided to IMPORT

package/src/duckdb/src/function/scalar/strftime_format.cpp

@@ -408,7 +408,7 @@ string StrfTimeFormat::Format(timestamp_t timestamp, const string &format_str) {
 	auto time = Timestamp::GetTime(timestamp);
 
 	auto len = format.GetLength(date, time, 0, nullptr);
-	auto result = unique_ptr<char[]>(new char[len]);
+	auto result = make_unsafe_array<char>(len);
 	format.FormatString(date, time, result.get());
 	return string(result.get(), len);
 }
@@ -417,6 +417,7 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 	if (format_string.empty()) {
 		return "Empty format string";
 	}
+	format.format_specifier = format_string;
 	format.specifiers.clear();
 	format.literals.clear();
 	format.numeric_width.clear();

package/src/duckdb/src/function/scalar/string/concat.cpp

@@ -118,7 +118,7 @@ static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const Selecti
                               const SelectionVector &rsel, idx_t count, Vector &result) {
 	vector<idx_t> result_lengths(args.size(), 0);
 	vector<bool> has_results(args.size(), false);
-	auto orrified_data = unique_ptr<UnifiedVectorFormat[]>(new UnifiedVectorFormat[args.ColumnCount() - 1]);
+	auto orrified_data = make_unsafe_array<UnifiedVectorFormat>(args.ColumnCount() - 1);
 	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
 		args.data[col_idx].ToUnifiedFormat(args.size(), orrified_data[col_idx - 1]);
 	}

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -395,11 +395,11 @@ bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0')
 
 	// lowercase both the str and the pattern
 	idx_t str_llength = LowerFun::LowerLength(str_data, str_size);
-	auto str_ldata = unique_ptr<char[]>(new char[str_llength]);
+	auto str_ldata = make_unsafe_array<char>(str_llength);
 	LowerFun::LowerCase(str_data, str_size, str_ldata.get());
 
 	idx_t pat_llength = LowerFun::LowerLength(pat_data, pat_size);
-	auto pat_ldata = unique_ptr<char[]>(new char[pat_llength]);
+	auto pat_ldata = make_unsafe_array<char>(pat_llength);
 	LowerFun::LowerCase(pat_data, pat_size, pat_ldata.get());
 	string_t str_lcase(str_ldata.get(), str_llength);
 	string_t pat_lcase(pat_ldata.get(), pat_llength);