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

package/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp

@@ -124,7 +124,8 @@ public:
 	//! Turn all the vectors from the chunk into flat vectors
 	DUCKDB_API void Flatten();
 
-	DUCKDB_API unique_ptr<UnifiedVectorFormat[]> ToUnifiedFormat();
+	// FIXME: this is DUCKDB_API, might need conversion back to regular unique ptr?
+	DUCKDB_API unsafe_array_ptr<UnifiedVectorFormat> ToUnifiedFormat();
 
 	DUCKDB_API void Slice(const SelectionVector &sel_vector, idx_t count);
 

package/src/duckdb/src/include/duckdb/common/types/selection_vector.hpp

@@ -18,7 +18,7 @@ class VectorBuffer;
 struct SelectionData {
 	DUCKDB_API explicit SelectionData(idx_t count);
 
-	unique_ptr<sel_t[]> owned_data;
+	unsafe_array_ptr<sel_t> owned_data;
 };
 
 struct SelectionVector {

package/src/duckdb/src/include/duckdb/common/types/validity_mask.hpp

@@ -24,7 +24,7 @@ struct TemplatedValidityData {
 public:
 	inline explicit TemplatedValidityData(idx_t count) {
 		auto entry_count = EntryCount(count);
-		owned_data = unique_ptr<V[]>(new V[entry_count]);
+		owned_data = make_unsafe_array<V>(entry_count);
 		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
 			owned_data[entry_idx] = MAX_ENTRY;
 		}
@@ -32,13 +32,13 @@ public:
 	inline TemplatedValidityData(const V *validity_mask, idx_t count) {
 		D_ASSERT(validity_mask);
 		auto entry_count = EntryCount(count);
-		owned_data = unique_ptr<V[]>(new V[entry_count]);
+		owned_data = make_unsafe_array<V>(entry_count);
 		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
 			owned_data[entry_idx] = validity_mask[entry_idx];
 		}
 	}
 
-	unique_ptr<V[]> owned_data;
+	unsafe_array_ptr<V> owned_data;
 
 public:
 	static inline idx_t EntryCount(idx_t count) {

package/src/duckdb/src/include/duckdb/common/types/vector_buffer.hpp

@@ -71,10 +71,10 @@ public:
 	}
 	explicit VectorBuffer(idx_t data_size) : buffer_type(VectorBufferType::STANDARD_BUFFER) {
 		if (data_size > 0) {
-			data = unique_ptr<data_t[]>(new data_t[data_size]);
+			data = make_unsafe_array<data_t>(data_size);
 		}
 	}
-	explicit VectorBuffer(unique_ptr<data_t[]> data_p)
+	explicit VectorBuffer(unsafe_array_ptr<data_t> data_p)
 	    : buffer_type(VectorBufferType::STANDARD_BUFFER), data(std::move(data_p)) {
 	}
 	virtual ~VectorBuffer() {
@@ -87,7 +87,7 @@ public:
 		return data.get();
 	}
 
-	void SetData(unique_ptr<data_t[]> new_data) {
+	void SetData(unsafe_array_ptr<data_t> new_data) {
 		data = std::move(new_data);
 	}
 
@@ -120,7 +120,7 @@ public:
 protected:
 	VectorBufferType buffer_type;
 	unique_ptr<VectorAuxiliaryData> aux_data;
-	unique_ptr<data_t[]> data;
+	unsafe_array_ptr<data_t> data;
 };
 
 //! The DictionaryBuffer holds a selection vector
@@ -241,12 +241,22 @@ public:
 
 	void PushBack(const Value &insert);
 
-	idx_t capacity = 0;
-	idx_t size = 0;
+	idx_t GetSize() {
+		return size;
+	}
+
+	idx_t GetCapacity() {
+		return capacity;
+	}
+
+	void SetCapacity(idx_t new_capacity);
+	void SetSize(idx_t new_size);
 
 private:
 	//! child vectors used for nested data
 	unique_ptr<Vector> child;
+	idx_t capacity = 0;
+	idx_t size = 0;
 };
 
 //! The ManagedVectorBuffer holds a buffer handle

package/src/duckdb/src/include/duckdb/common/unique_ptr.hpp

@@ -2,38 +2,45 @@
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/likely.hpp"
+#include "duckdb/common/memory_safety.hpp"
 
 #include <memory>
 #include <type_traits>
 
 namespace duckdb {
 
-namespace {
-struct __unique_ptr_utils {
-	static inline void AssertNotNull(void *ptr) {
-#ifdef DEBUG
-		if (DUCKDB_UNLIKELY(!ptr)) {
-			throw InternalException("Attempted to dereference unique_ptr that is NULL!");
+template <class _Tp, bool SAFE = true>
+class unique_ptr : public std::unique_ptr<_Tp, std::default_delete<_Tp>> {
+public:
+	using original = std::unique_ptr<_Tp, std::default_delete<_Tp>>;
+	using original::original;
+
+private:
+	static inline void AssertNotNull(const bool null) {
+#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
+		return;
+#else
+		if (DUCKDB_UNLIKELY(null)) {
+			throw duckdb::InternalException("Attempted to dereference unique_ptr that is NULL!");
 		}
 #endif
 	}
-};
-} // namespace
 
-template <class _Tp, class _Dp = std::default_delete<_Tp>>
-class unique_ptr : public std::unique_ptr<_Tp, _Dp> {
 public:
-	using original = std::unique_ptr<_Tp, _Dp>;
-	using original::original;
-
 	typename std::add_lvalue_reference<_Tp>::type operator*() const {
-		__unique_ptr_utils::AssertNotNull((void *)original::get());
-		return *(original::get());
+		const auto ptr = original::get();
+		if (MemorySafety<SAFE>::enabled) {
+			AssertNotNull(!ptr);
+		}
+		return *ptr;
 	}
 
 	typename original::pointer operator->() const {
-		__unique_ptr_utils::AssertNotNull((void *)original::get());
-		return original::get();
+		const auto ptr = original::get();
+		if (MemorySafety<SAFE>::enabled) {
+			AssertNotNull(!ptr);
+		}
+		return ptr;
 	}
 
 #ifdef DUCKDB_CLANG_TIDY
@@ -46,16 +53,40 @@ public:
 	}
 };
 
-template <class _Tp, class _Dp>
-class unique_ptr<_Tp[], _Dp> : public std::unique_ptr<_Tp[], _Dp> {
+template <class _Tp, bool SAFE>
+class unique_ptr<_Tp[], SAFE> : public std::unique_ptr<_Tp[], std::default_delete<_Tp[]>> {
 public:
-	using original = std::unique_ptr<_Tp[], _Dp>;
+	using original = std::unique_ptr<_Tp[], std::default_delete<_Tp[]>>;
 	using original::original;
 
+private:
+	static inline void AssertNotNull(const bool null) {
+#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
+		return;
+#else
+		if (DUCKDB_UNLIKELY(null)) {
+			throw duckdb::InternalException("Attempted to dereference unique_ptr that is NULL!");
+		}
+#endif
+	}
+
+public:
 	typename std::add_lvalue_reference<_Tp>::type operator[](size_t __i) const {
-		__unique_ptr_utils::AssertNotNull((void *)original::get());
-		return (original::get())[__i];
+		const auto ptr = original::get();
+		if (MemorySafety<SAFE>::enabled) {
+			AssertNotNull(!ptr);
+		}
+		return ptr[__i];
 	}
 };
 
+template <typename T>
+using array_ptr = unique_ptr<T[], true>;
+
+template <typename T>
+using unsafe_array_ptr = unique_ptr<T[], false>;
+
+template <typename T>
+using unsafe_unique_ptr = unique_ptr<T, false>;
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/vector.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/typedefs.hpp"
 #include "duckdb/common/likely.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/memory_safety.hpp"
 #include <vector>
 
 namespace duckdb {
@@ -25,6 +26,7 @@ public:
 	using const_reference = typename original::const_reference;
 	using reference = typename original::reference;
 
+private:
 	static inline void AssertIndexInBounds(idx_t index, idx_t size) {
 #if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
 		return;
@@ -35,6 +37,7 @@ public:
 #endif
 	}
 
+public:
 #ifdef DUCKDB_CLANG_TIDY
 	// This is necessary to tell clang-tidy that it reinitializes the variable after a move
 	[[clang::reinitializes]]
@@ -55,7 +58,7 @@ public:
 
 	template <bool _SAFE = false>
 	inline typename original::reference get(typename original::size_type __n) {
-		if (_SAFE) {
+		if (MemorySafety<_SAFE>::enabled) {
 			AssertIndexInBounds(__n, original::size());
 		}
 		return original::operator[](__n);
@@ -63,7 +66,7 @@ public:
 
 	template <bool _SAFE = false>
 	inline typename original::const_reference get(typename original::size_type __n) const {
-		if (_SAFE) {
+		if (MemorySafety<_SAFE>::enabled) {
 			AssertIndexInBounds(__n, original::size());
 		}
 		return original::operator[](__n);

package/src/duckdb/src/include/duckdb/execution/aggregate_hashtable.hpp

@@ -73,7 +73,7 @@ struct AggregateHTAppendState {
 	SelectionVector empty_vector;
 	SelectionVector new_groups;
 	Vector addresses;
-	unique_ptr<UnifiedVectorFormat[]> group_data;
+	unsafe_array_ptr<UnifiedVectorFormat> group_data;
 	DataChunk group_chunk;
 
 	TupleDataChunkState chunk_state;

package/src/duckdb/src/include/duckdb/execution/join_hashtable.hpp

@@ -65,12 +65,12 @@ public:
 	//! returned by the JoinHashTable::Scan function and can be used to resume a
 	//! probe.
 	struct ScanStructure {
-		unique_ptr<UnifiedVectorFormat[]> key_data;
+		unsafe_array_ptr<UnifiedVectorFormat> key_data;
 		Vector pointers;
 		idx_t count;
 		SelectionVector sel_vector;
 		// whether or not the given tuple has found a match
-		unique_ptr<bool[]> found_match;
+		unsafe_array_ptr<bool> found_match;
 		JoinHashTable &ht;
 		bool finished;
 
@@ -212,8 +212,8 @@ private:
 	//! Insert the given set of locations into the HT with the given set of hashes
 	void InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[], bool parallel);
 
-	idx_t PrepareKeys(DataChunk &keys, unique_ptr<UnifiedVectorFormat[]> &key_data, const SelectionVector *&current_sel,
-	                  SelectionVector &sel, bool build_side);
+	idx_t PrepareKeys(DataChunk &keys, unsafe_array_ptr<UnifiedVectorFormat> &key_data,
+	                  const SelectionVector *&current_sel, SelectionVector &sel, bool build_side);
 
 	//! Lock for combining data_collection when merging HTs
 	mutex data_lock;

package/src/duckdb/src/include/duckdb/execution/operator/join/outer_join_marker.hpp

@@ -67,7 +67,7 @@ public:
 
 private:
 	bool enabled;
-	unique_ptr<bool[]> found_match;
+	unsafe_array_ptr<bool> found_match;
 	idx_t count;
 };
 

package/src/duckdb/src/include/duckdb/execution/operator/join/perfect_hash_join_executor.hpp

@@ -68,7 +68,7 @@ private:
 	//! Build and probe statistics
 	PerfectHashJoinStats perfect_join_statistics;
 	//! Stores the occurences of each value in the build side
-	unique_ptr<bool[]> bitmap_build_idx;
+	unsafe_array_ptr<bool> bitmap_build_idx;
 	//! Stores the number of unique keys in the build side
 	idx_t unique_keys = 0;
 };

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_range_join.hpp

@@ -83,7 +83,7 @@ public:
 		//! The total number of rows in the RHS
 		atomic<idx_t> count;
 		//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
-		unique_ptr<bool[]> found_match;
+		unsafe_array_ptr<bool> found_match;
 		//! Memory usage per thread
 		idx_t memory_per_thread;
 	};

package/src/duckdb/src/include/duckdb/execution/operator/persistent/base_csv_reader.hpp

@@ -61,8 +61,6 @@ public:
 
 	DataChunk parse_chunk;
 
-	std::queue<unique_ptr<DataChunk>> cached_chunks;
-
 	ParserMode mode;
 
 public:

package/src/duckdb/src/include/duckdb/execution/operator/persistent/buffered_csv_reader.hpp

@@ -60,12 +60,12 @@ public:
 	virtual ~BufferedCSVReader() {
 	}
 
-	unique_ptr<char[]> buffer;
+	unsafe_array_ptr<char> buffer;
 	idx_t buffer_size;
 	idx_t position;
 	idx_t start = 0;
 
-	vector<unique_ptr<char[]>> cached_buffers;
+	vector<unsafe_array_ptr<char>> cached_buffers;
 
 	unique_ptr<CSVFileHandle> file_handle;
 

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_file_handle.hpp

@@ -11,152 +11,52 @@
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/helper.hpp"
+#include "duckdb/common/allocator.hpp"
 
 namespace duckdb {
+class Allocator;
+class FileSystem;
 
 struct CSVFileHandle {
 public:
-	explicit CSVFileHandle(unique_ptr<FileHandle> file_handle_p, bool enable_reset = true)
-	    : file_handle(std::move(file_handle_p)), reset_enabled(enable_reset) {
-		can_seek = file_handle->CanSeek();
-		plain_file_source = file_handle->OnDiskFile() && can_seek;
-		file_size = file_handle->GetFileSize();
-	}
+	CSVFileHandle(FileSystem &fs, Allocator &allocator, unique_ptr<FileHandle> file_handle_p, const string &path_p,
+	              FileCompressionType compression, bool enable_reset = true);
 
-	bool CanSeek() {
-		return can_seek;
-	}
-	void Seek(idx_t position) {
-		if (!can_seek) {
-			throw InternalException("Cannot seek in this file");
-		}
-		file_handle->Seek(position);
-	}
-	idx_t SeekPosition() {
-		if (!can_seek) {
-			throw InternalException("Cannot seek in this file");
-		}
-		return file_handle->SeekPosition();
-	}
-	void Reset() {
-		if (plain_file_source) {
-			file_handle->Reset();
-		} else {
-			if (!reset_enabled) {
-				throw InternalException("Reset called but reset is not enabled for this CSV Handle");
-			}
-			read_position = 0;
-		}
-	}
-	bool PlainFileSource() {
-		return plain_file_source;
-	}
-
-	bool OnDiskFile() {
-		return file_handle->OnDiskFile();
-	}
-
-	idx_t FileSize() {
-		return file_size;
-	}
+	mutex main_mutex;
 
-	bool FinishedReading() {
-		return requested_bytes >= file_size;
-	}
+public:
+	bool CanSeek();
+	void Seek(idx_t position);
+	idx_t SeekPosition();
+	void Reset();
+	bool OnDiskFile();
 
-	idx_t Read(void *buffer, idx_t nr_bytes) {
-		requested_bytes += nr_bytes;
-		if (!plain_file_source) {
-			// 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) {
-				// 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);
+	idx_t FileSize();
 
-					auto new_buffer = unique_ptr<data_t[]>(new data_t[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;
-			}
+	bool FinishedReading();
 
-			return result_offset + bytes_read;
-		} else {
-			return file_handle->Read(buffer, nr_bytes);
-		}
-	}
+	idx_t Read(void *buffer, idx_t nr_bytes);
 
-	string 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;
-			}
-		}
-	}
+	string ReadLine();
+	void DisableReset();
 
-	void DisableReset() {
-		this->reset_enabled = false;
-	}
-	mutex main_mutex;
-	idx_t count = 0;
+	static unique_ptr<FileHandle> OpenFileHandle(FileSystem &fs, Allocator &allocator, const string &path,
+	                                             FileCompressionType compression);
+	static unique_ptr<CSVFileHandle> OpenFile(FileSystem &fs, Allocator &allocator, const string &path,
+	                                          FileCompressionType compression, bool enable_reset);
 
 private:
+	FileSystem &fs;
+	Allocator &allocator;
 	unique_ptr<FileHandle> file_handle;
+	string path;
+	FileCompressionType compression;
 	bool reset_enabled = true;
 	bool can_seek = false;
-	bool plain_file_source = false;
+	bool on_disk_file = false;
 	idx_t file_size = 0;
 	// reset support
-	unique_ptr<data_t[]> cached_buffer;
+	AllocatedData cached_buffer;
 	idx_t read_position = 0;
 	idx_t buffer_size = 0;
 	idx_t buffer_capacity = 0;

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_reader_options.hpp

@@ -130,8 +130,7 @@ struct BufferedCSVReaderOptions {
 	std::map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}},
 	                                                             {LogicalTypeId::TIMESTAMP, {}}};
 	//! Whether or not a type format is specified
-	std::map<LogicalTypeId, bool> has_format = {
-	    {LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}, {LogicalTypeId::TIMESTAMP_TZ, false}};
+	std::map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
 
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);

package/src/duckdb/src/include/duckdb/execution/operator/persistent/parallel_csv_reader.hpp

@@ -67,7 +67,7 @@ struct CSVBufferRead {
 		} else {
 			// 3) It starts in the current buffer and ends in the next buffer
 			D_ASSERT(next_buffer);
-			auto intersection = unique_ptr<char[]>(new char[length]);
+			auto intersection = make_unsafe_array<char>(length);
 			idx_t cur_pos = 0;
 			auto buffer_ptr = buffer->Ptr();
 			for (idx_t i = start_buffer; i < buffer->GetBufferSize(); i++) {
@@ -85,7 +85,7 @@ struct CSVBufferRead {
 
 	shared_ptr<CSVBuffer> buffer;
 	shared_ptr<CSVBuffer> next_buffer;
-	vector<unique_ptr<char[]>> intersections;
+	vector<unsafe_array_ptr<char>> intersections;
 	optional_ptr<LineInfo> line_info;
 
 	idx_t buffer_start;

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp

@@ -38,7 +38,7 @@ public:
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
 
 	bool IsSink() const override {
-		return info->query != nullptr;
+		return !children.empty();
 	}
 
 	bool ParallelSink() const override {

package/src/duckdb/src/include/duckdb/execution/perfect_aggregate_hashtable.hpp

@@ -46,9 +46,9 @@ protected:
 	// The actual pointer to the data
 	data_ptr_t data;
 	//! The owned data of the HT
-	unique_ptr<data_t[]> owned_data;
+	unsafe_array_ptr<data_t> owned_data;
 	//! Information on whether or not a specific group has any entries
-	unique_ptr<bool[]> group_is_set;
+	unsafe_array_ptr<bool> group_is_set;
 
 	//! The minimum values for each of the group columns
 	vector<Value> group_minima;

package/src/duckdb/src/include/duckdb/execution/window_segment_tree.hpp

@@ -113,7 +113,7 @@ private:
 	Vector statev;
 
 	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
-	unique_ptr<data_t[]> levels_flat_native;
+	unsafe_array_ptr<data_t> levels_flat_native;
 	//! For each level, the starting location in the levels_flat_native array
 	vector<idx_t> levels_flat_start;
 

package/src/duckdb/src/include/duckdb/function/macro_function.hpp

@@ -21,7 +21,7 @@ enum class MacroType : uint8_t { VOID_MACRO = 0, TABLE_MACRO = 1, SCALAR_MACRO =
 
 class MacroFunction {
 public:
-	MacroFunction(MacroType type);
+	explicit MacroFunction(MacroType type);
 
 	//! The type
 	MacroType type;
@@ -45,6 +45,12 @@ public:
 
 	virtual string ToSQL(const string &schema, const string &name) const;
 
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
+
+protected:
+	virtual void SerializeInternal(FieldWriter &writer) const = 0;
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -66,6 +66,9 @@ public:
 		return std::find(specifiers.begin(), specifiers.end(), s) != specifiers.end();
 	}
 
+	//! The full format specifier, for error messages
+	string format_specifier;
+
 protected:
 	//! The format specifiers
 	vector<StrTimeSpecifier> specifiers;
@@ -134,10 +137,6 @@ public:
 		DUCKDB_API string FormatError(string_t input, const string &format_specifier);
 	};
 
-public:
-	//! The full format specifier, for error messages
-	string format_specifier;
-
 public:
 	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
 

package/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp

@@ -23,9 +23,9 @@ public:
 	static constexpr const MacroType TYPE = MacroType::SCALAR_MACRO;
 
 public:
-	ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
-
+	explicit ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
 	ScalarMacroFunction(void);
+
 	//! The macro expression
 	unique_ptr<ParsedExpression> expression;
 
@@ -33,6 +33,11 @@ public:
 	unique_ptr<MacroFunction> Copy() const override;
 
 	string ToSQL(const string &schema, const string &name) const override;
+
+	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
+
+protected:
+	void SerializeInternal(FieldWriter &writer) const override;
 };
 
 } // namespace duckdb