duckdb 0.3.2-dev992.0 → 0.3.3-dev6.0

package/src/duckdb.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2018 DuckDB Contributors (see https://github.com/duckdb/duckdb/graphs/contributors)
+Copyright 2018-2022 Stichting DuckDB Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "c16a2f0cb"
-#define DUCKDB_VERSION "0.3.2-dev992"
+#define DUCKDB_SOURCE_ID "c66fa5ef9"
+#define DUCKDB_VERSION "v0.3.3-dev6"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -371,13 +371,15 @@ void AssignSharedPointer(shared_ptr<T> &target, const shared_ptr<T> &source) {
 
 
 
+
+
 #if (defined(DUCKDB_USE_STANDARD_ASSERT) || !defined(DEBUG)) && !defined(DUCKDB_FORCE_ASSERT)
 
 #include <assert.h>
 #define D_ASSERT assert
 #else
 namespace duckdb {
-void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr);
+DUCKDB_API void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr);
 }
 
 #define D_ASSERT(condition) duckdb::DuckDBAssertInternal(bool(condition), #condition, __FILE__, __LINE__)
@@ -1548,6 +1550,7 @@ public:
 } // namespace duckdb
 
 
+#include <type_traits>
 
 namespace duckdb {
 
@@ -1561,19 +1564,18 @@ public:
 
 	template <class T>
 	void Write(T element) {
+		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
+
 		WriteData((const_data_ptr_t)&element, sizeof(T));
 	}
 
-	//! Write data from a string buffer directly (wihtout length prefix)
+	//! Write data from a string buffer directly (without length prefix)
 	void WriteBufferData(const string &str) {
 		WriteData((const_data_ptr_t)str.c_str(), str.size());
 	}
 	//! Write a string with a length prefix
 	void WriteString(const string &val) {
-		Write<uint32_t>((uint32_t)val.size());
-		if (!val.empty()) {
-			WriteData((const_data_ptr_t)val.c_str(), val.size());
-		}
+		WriteStringLen((const_data_ptr_t)val.c_str(), val.size());
 	}
 	void WriteStringLen(const_data_ptr_t val, idx_t len) {
 		Write<uint32_t>((uint32_t)len);
@@ -1583,7 +1585,7 @@ public:
 	}
 
 	template <class T>
-	void WriteList(vector<unique_ptr<T>> &list) {
+	void WriteList(const vector<unique_ptr<T>> &list) {
 		Write<uint32_t>((uint32_t)list.size());
 		for (auto &child : list) {
 			child->Serialize(*this);
@@ -1812,30 +1814,28 @@ enum class FileType {
 
 struct FileHandle {
 public:
-	FileHandle(FileSystem &file_system, string path) : file_system(file_system), path(path) {
-	}
+	DUCKDB_API FileHandle(FileSystem &file_system, string path);
 	FileHandle(const FileHandle &) = delete;
-	virtual ~FileHandle() {
-	}
+	DUCKDB_API virtual ~FileHandle();
 
-	int64_t Read(void *buffer, idx_t nr_bytes);
-	int64_t Write(void *buffer, idx_t nr_bytes);
-	void Read(void *buffer, idx_t nr_bytes, idx_t location);
-	void Write(void *buffer, idx_t nr_bytes, idx_t location);
-	void Seek(idx_t location);
-	void Reset();
-	idx_t SeekPosition();
-	void Sync();
-	void Truncate(int64_t new_size);
-	string ReadLine();
+	DUCKDB_API int64_t Read(void *buffer, idx_t nr_bytes);
+	DUCKDB_API int64_t Write(void *buffer, idx_t nr_bytes);
+	DUCKDB_API void Read(void *buffer, idx_t nr_bytes, idx_t location);
+	DUCKDB_API void Write(void *buffer, idx_t nr_bytes, idx_t location);
+	DUCKDB_API void Seek(idx_t location);
+	DUCKDB_API void Reset();
+	DUCKDB_API idx_t SeekPosition();
+	DUCKDB_API void Sync();
+	DUCKDB_API void Truncate(int64_t new_size);
+	DUCKDB_API string ReadLine();
 
-	bool CanSeek();
-	bool OnDiskFile();
-	idx_t GetFileSize();
-	FileType GetType();
+	DUCKDB_API bool CanSeek();
+	DUCKDB_API bool OnDiskFile();
+	DUCKDB_API idx_t GetFileSize();
+	DUCKDB_API FileType GetType();
 
 	//! Closes the file handle.
-	virtual void Close() = 0;
+	DUCKDB_API virtual void Close() = 0;
 
 public:
 	FileSystem &file_system;
@@ -1862,107 +1862,107 @@ public:
 
 class FileSystem {
 public:
-	virtual ~FileSystem() {
-	}
+	DUCKDB_API virtual ~FileSystem();
 
 public:
-	static constexpr FileLockType DEFAULT_LOCK = FileLockType::NO_LOCK;
-	static constexpr FileCompressionType DEFAULT_COMPRESSION = FileCompressionType::UNCOMPRESSED;
-	static FileSystem &GetFileSystem(ClientContext &context);
-	static FileSystem &GetFileSystem(DatabaseInstance &db);
-	static FileOpener *GetFileOpener(ClientContext &context);
+	DUCKDB_API static constexpr FileLockType DEFAULT_LOCK = FileLockType::NO_LOCK;
+	DUCKDB_API static constexpr FileCompressionType DEFAULT_COMPRESSION = FileCompressionType::UNCOMPRESSED;
+	DUCKDB_API static FileSystem &GetFileSystem(ClientContext &context);
+	DUCKDB_API static FileSystem &GetFileSystem(DatabaseInstance &db);
+	DUCKDB_API static FileOpener *GetFileOpener(ClientContext &context);
 
-	virtual unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags, FileLockType lock = DEFAULT_LOCK,
-	                                        FileCompressionType compression = DEFAULT_COMPRESSION,
-	                                        FileOpener *opener = nullptr);
+	DUCKDB_API virtual unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags,
+	                                                   FileLockType lock = DEFAULT_LOCK,
+	                                                   FileCompressionType compression = DEFAULT_COMPRESSION,
+	                                                   FileOpener *opener = nullptr);
 
 	//! Read exactly nr_bytes from the specified location in the file. Fails if nr_bytes could not be read. This is
 	//! equivalent to calling SetFilePointer(location) followed by calling Read().
-	virtual void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
+	DUCKDB_API virtual void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
 	//! Write exactly nr_bytes to the specified location in the file. Fails if nr_bytes could not be read. This is
 	//! equivalent to calling SetFilePointer(location) followed by calling Write().
-	virtual void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
+	DUCKDB_API virtual void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
 	//! Read nr_bytes from the specified file into the buffer, moving the file pointer forward by nr_bytes. Returns the
 	//! amount of bytes read.
-	virtual int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes);
+	DUCKDB_API virtual int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes);
 	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
-	virtual int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes);
+	DUCKDB_API virtual int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes);
 
 	//! Returns the file size of a file handle, returns -1 on error
-	virtual int64_t GetFileSize(FileHandle &handle);
+	DUCKDB_API virtual int64_t GetFileSize(FileHandle &handle);
 	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	virtual time_t GetLastModifiedTime(FileHandle &handle);
+	DUCKDB_API virtual time_t GetLastModifiedTime(FileHandle &handle);
 	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	virtual FileType GetFileType(FileHandle &handle);
+	DUCKDB_API virtual FileType GetFileType(FileHandle &handle);
 	//! Truncate a file to a maximum size of new_size, new_size should be smaller than or equal to the current size of
 	//! the file
-	virtual void Truncate(FileHandle &handle, int64_t new_size);
+	DUCKDB_API virtual void Truncate(FileHandle &handle, int64_t new_size);
 
 	//! Check if a directory exists
-	virtual bool DirectoryExists(const string &directory);
+	DUCKDB_API virtual bool DirectoryExists(const string &directory);
 	//! Create a directory if it does not exist
-	virtual void CreateDirectory(const string &directory);
+	DUCKDB_API virtual void CreateDirectory(const string &directory);
 	//! Recursively remove a directory and all files in it
-	virtual void RemoveDirectory(const string &directory);
+	DUCKDB_API virtual void RemoveDirectory(const string &directory);
 	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
-	virtual bool ListFiles(const string &directory, const std::function<void(string, bool)> &callback);
+	DUCKDB_API virtual bool ListFiles(const string &directory, const std::function<void(string, bool)> &callback);
 	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
 	//! properties
-	virtual void MoveFile(const string &source, const string &target);
+	DUCKDB_API virtual void MoveFile(const string &source, const string &target);
 	//! Check if a file exists
-	virtual bool FileExists(const string &filename);
+	DUCKDB_API virtual bool FileExists(const string &filename);
 	//! Remove a file from disk
-	virtual void RemoveFile(const string &filename);
+	DUCKDB_API virtual void RemoveFile(const string &filename);
 	//! Sync a file handle to disk
-	virtual void FileSync(FileHandle &handle);
+	DUCKDB_API virtual void FileSync(FileHandle &handle);
 
 	//! Sets the working directory
-	static void SetWorkingDirectory(const string &path);
+	DUCKDB_API static void SetWorkingDirectory(const string &path);
 	//! Gets the working directory
-	static string GetWorkingDirectory();
+	DUCKDB_API static string GetWorkingDirectory();
 	//! Gets the users home directory
-	static string GetHomeDirectory();
+	DUCKDB_API static string GetHomeDirectory();
 	//! Returns the system-available memory in bytes
-	static idx_t GetAvailableMemory();
+	DUCKDB_API static idx_t GetAvailableMemory();
 	//! Path separator for the current file system
-	static string PathSeparator();
+	DUCKDB_API static string PathSeparator();
 	//! Join two paths together
-	static string JoinPath(const string &a, const string &path);
+	DUCKDB_API static string JoinPath(const string &a, const string &path);
 	//! Convert separators in a path to the local separators (e.g. convert "/" into \\ on windows)
-	static string ConvertSeparators(const string &path);
+	DUCKDB_API static string ConvertSeparators(const string &path);
 	//! Extract the base name of a file (e.g. if the input is lib/example.dll the base name is example)
-	static string ExtractBaseName(const string &path);
+	DUCKDB_API static string ExtractBaseName(const string &path);
 
 	//! Runs a glob on the file system, returning a list of matching files
-	virtual vector<string> Glob(const string &path);
+	DUCKDB_API virtual vector<string> Glob(const string &path);
 
 	//! registers a sub-file system to handle certain file name prefixes, e.g. http:// etc.
-	virtual void RegisterSubSystem(unique_ptr<FileSystem> sub_fs);
-	virtual void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs);
+	DUCKDB_API virtual void RegisterSubSystem(unique_ptr<FileSystem> sub_fs);
+	DUCKDB_API virtual void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs);
 
 	//! Whether or not a sub-system can handle a specific file path
-	virtual bool CanHandleFile(const string &fpath);
+	DUCKDB_API virtual bool CanHandleFile(const string &fpath);
 
 	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
-	virtual void Seek(FileHandle &handle, idx_t location);
+	DUCKDB_API virtual void Seek(FileHandle &handle, idx_t location);
 	//! Reset a file to the beginning (equivalent to Seek(handle, 0) for simple files)
-	virtual void Reset(FileHandle &handle);
-	virtual idx_t SeekPosition(FileHandle &handle);
+	DUCKDB_API virtual void Reset(FileHandle &handle);
+	DUCKDB_API virtual idx_t SeekPosition(FileHandle &handle);
 
 	//! Whether or not we can seek into the file
-	virtual bool CanSeek();
+	DUCKDB_API virtual bool CanSeek();
 	//! Whether or not the FS handles plain files on disk. This is relevant for certain optimizations, as random reads
 	//! in a file on-disk are much cheaper than e.g. random reads in a file over the network
-	virtual bool OnDiskFile(FileHandle &handle);
+	DUCKDB_API virtual bool OnDiskFile(FileHandle &handle);
 
-	virtual unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write);
+	DUCKDB_API virtual unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write);
 
 	//! Create a LocalFileSystem.
-	static unique_ptr<FileSystem> CreateLocal();
+	DUCKDB_API static unique_ptr<FileSystem> CreateLocal();
 
 protected:
 	//! Return the name of the filesytem. Used for forming diagnosis messages.
-	virtual std::string GetName() const = 0;
+	DUCKDB_API virtual std::string GetName() const = 0;
 };
 
 } // namespace duckdb
@@ -2368,6 +2368,41 @@ public:
 		return true;
 	}
 
+	idx_t CountValid(const idx_t count) const {
+		if (AllValid() || count == 0) {
+			return count;
+		}
+
+		idx_t valid = 0;
+		const auto entry_count = EntryCount(count);
+		for (idx_t entry_idx = 0; entry_idx < entry_count;) {
+			auto entry = GetValidityEntry(entry_idx++);
+			// Handle ragged end
+			if (entry_idx == entry_count) {
+				idx_t idx_in_entry;
+				GetEntryIndex(count, entry_idx, idx_in_entry);
+				for (idx_t i = 0; i < idx_in_entry; ++i) {
+					valid += idx_t(RowIsValid(entry, i));
+				}
+				break;
+			}
+
+			// Handle all set
+			if (AllValid(entry)) {
+				valid += BITS_PER_VALUE;
+				continue;
+			}
+
+			// Count partial entry (Kernighan's algorithm)
+			while (entry) {
+				entry &= (entry - 1);
+				++valid;
+			}
+		}
+
+		return valid;
+	}
+
 	inline V *GetData() const {
 		return validity_mask;
 	}
@@ -2742,7 +2777,7 @@ public:
 	DUCKDB_API bool TryCastAs(const LogicalType &target_type, bool strict = false);
 
 	//! Serializes a Value to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer);
+	DUCKDB_API void Serialize(Serializer &serializer) const;
 	//! Deserializes a Value from a blob
 	DUCKDB_API static Value Deserialize(Deserializer &source);
 
@@ -3288,6 +3323,21 @@ enum class VectorBufferType : uint8_t {
 	OPAQUE_BUFFER        // opaque buffer, can be created for example by the parquet reader
 };
 
+enum class VectorAuxiliaryDataType : uint8_t {
+	ARROW_AUXILIARY // Holds Arrow Chunks that this vector depends on
+};
+
+struct VectorAuxiliaryData {
+	explicit VectorAuxiliaryData(VectorAuxiliaryDataType type_p)
+	    : type(type_p) {
+
+	      };
+	VectorAuxiliaryDataType type;
+
+	virtual ~VectorAuxiliaryData() {
+	}
+};
+
 //! The VectorBuffer is a class used by the vector to hold its data
 class VectorBuffer {
 public:
@@ -3310,10 +3360,19 @@ public:
 	data_ptr_t GetData() {
 		return data.get();
 	}
+
 	void SetData(unique_ptr<data_t[]> new_data) {
 		data = move(new_data);
 	}
 
+	VectorAuxiliaryData *GetAuxiliaryData() {
+		return aux_data.get();
+	}
+
+	void SetAuxiliaryData(unique_ptr<VectorAuxiliaryData> aux_data_p, VectorAuxiliaryDataType aux_type_p) {
+		aux_data = move(aux_data_p);
+	}
+
 	static buffer_ptr<VectorBuffer> CreateStandardVector(PhysicalType type, idx_t capacity = STANDARD_VECTOR_SIZE);
 	static buffer_ptr<VectorBuffer> CreateConstantVector(PhysicalType type);
 	static buffer_ptr<VectorBuffer> CreateConstantVector(const LogicalType &logical_type);
@@ -3324,8 +3383,13 @@ public:
 		return buffer_type;
 	}
 
+	inline VectorAuxiliaryDataType GetAuxiliaryDataType() const {
+		return aux_data->type;
+	}
+
 protected:
 	VectorBufferType buffer_type;
+	unique_ptr<VectorAuxiliaryData> aux_data;
 	unique_ptr<data_t[]> data;
 };
 
@@ -3811,6 +3875,141 @@ struct SequenceVector {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/arrow_wrapper.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/arrow.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ARROW_FLAG_DICTIONARY_ORDERED
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ARROW_FLAG_DICTIONARY_ORDERED 1
+#define ARROW_FLAG_NULLABLE           2
+#define ARROW_FLAG_MAP_KEYS_SORTED    4
+
+struct ArrowSchema {
+	// Array type description
+	const char *format;
+	const char *name;
+	const char *metadata;
+	int64_t flags;
+	int64_t n_children;
+	struct ArrowSchema **children;
+	struct ArrowSchema *dictionary;
+
+	// Release callback
+	void (*release)(struct ArrowSchema *);
+	// Opaque producer-specific data
+	void *private_data;
+};
+
+struct ArrowArray {
+	// Array data description
+	int64_t length;
+	int64_t null_count;
+	int64_t offset;
+	int64_t n_buffers;
+	int64_t n_children;
+	const void **buffers;
+	struct ArrowArray **children;
+	struct ArrowArray *dictionary;
+
+	// Release callback
+	void (*release)(struct ArrowArray *);
+	// Opaque producer-specific data
+	void *private_data;
+};
+
+// EXPERIMENTAL
+struct ArrowArrayStream {
+	// Callback to get the stream type
+	// (will be the same for all arrays in the stream).
+	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
+	int (*get_schema)(struct ArrowArrayStream *, struct ArrowSchema *out);
+	// Callback to get the next array
+	// (if no error and the array is released, the stream has ended)
+	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
+	int (*get_next)(struct ArrowArrayStream *, struct ArrowArray *out);
+
+	// Callback to get optional detailed error information.
+	// This must only be called if the last stream operation failed
+	// with a non-0 return code.  The returned pointer is only valid until
+	// the next operation on this stream (including release).
+	// If unavailable, NULL is returned.
+	const char *(*get_last_error)(struct ArrowArrayStream *);
+
+	// Release callback: release the stream's own resources.
+	// Note that arrays returned by `get_next` must be individually released.
+	void (*release)(struct ArrowArrayStream *);
+	// Opaque producer-specific data
+	void *private_data;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+
+//! Here we have the internal duckdb classes that interact with Arrow's Internal Header (i.e., duckdb/commons/arrow.hpp)
+namespace duckdb {
+class ArrowSchemaWrapper {
+public:
+	ArrowSchema arrow_schema;
+
+	ArrowSchemaWrapper() {
+		arrow_schema.release = nullptr;
+	}
+
+	~ArrowSchemaWrapper();
+};
+class ArrowArrayWrapper {
+public:
+	ArrowArray arrow_array;
+	ArrowArrayWrapper() {
+		arrow_array.length = 0;
+		arrow_array.release = nullptr;
+	}
+	~ArrowArrayWrapper();
+};
+
+class ArrowArrayStreamWrapper {
+public:
+	ArrowArrayStream arrow_array_stream;
+	int64_t number_of_rows;
+	void GetSchema(ArrowSchemaWrapper &schema);
+
+	shared_ptr<ArrowArrayWrapper> GetNextChunk();
+
+	const char *GetError();
+
+	~ArrowArrayStreamWrapper();
+	ArrowArrayStreamWrapper() {
+		arrow_array_stream.release = nullptr;
+	}
+};
+} // namespace duckdb
+
+
 struct ArrowArray;
 
 namespace duckdb {
@@ -5258,27 +5457,20 @@ private:
 
 
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/unordered_set.hpp
+// duckdb/common/named_parameter_map.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
-#include <unordered_set>
-
-namespace duckdb {
-using std::unordered_set;
-}
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/column_definition.hpp
+// duckdb/common/case_insensitive_map.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -5286,32 +5478,27 @@ using std::unordered_set;
 
 
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_expression.hpp
+// duckdb/common/unordered_set.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/base_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
+#include <unordered_set>
 
+namespace duckdb {
+using std::unordered_set;
+}
 
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/enums/expression_type.hpp
+// duckdb/common/string_util.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -5320,33 +5507,230 @@ using std::unordered_set;
 
 
 
+
+
 namespace duckdb {
+/**
+ * String Utility Functions
+ * Note that these are not the most efficient implementations (i.e., they copy
+ * memory) and therefore they should only be used for debug messages and other
+ * such things.
+ */
+class StringUtil {
+public:
+	DUCKDB_API static bool CharacterIsSpace(char c) {
+		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+	}
+	DUCKDB_API static bool CharacterIsNewline(char c) {
+		return c == '\n' || c == '\r';
+	}
+	DUCKDB_API static bool CharacterIsDigit(char c) {
+		return c >= '0' && c <= '9';
+	}
+	DUCKDB_API static char CharacterToLower(char c) {
+		if (c >= 'A' && c <= 'Z') {
+			return c - ('A' - 'a');
+		}
+		return c;
+	}
 
-//===--------------------------------------------------------------------===//
-// Predicate Expression Operation Types
-//===--------------------------------------------------------------------===//
-enum class ExpressionType : uint8_t {
-	INVALID = 0,
+	//! Returns true if the needle string exists in the haystack
+	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
 
-	// explicitly cast left as right (right is integer in ValueType enum)
-	OPERATOR_CAST = 12,
-	// logical not operator
-	OPERATOR_NOT = 13,
-	// is null operator
-	OPERATOR_IS_NULL = 14,
-	// is not null operator
-	OPERATOR_IS_NOT_NULL = 15,
+	//! Returns true if the target string starts with the given prefix
+	DUCKDB_API static bool StartsWith(string str, string prefix);
 
-	// -----------------------------
-	// Comparison Operators
-	// -----------------------------
-	// equal operator between left and right
-	COMPARE_EQUAL = 25,
-	// compare initial boundary
-	COMPARE_BOUNDARY_START = COMPARE_EQUAL,
-	// inequal operator between left and right
-	COMPARE_NOTEQUAL = 26,
-	// less than operator between left and right
+	//! Returns true if the target string <b>ends</b> with the given suffix.
+	DUCKDB_API static bool EndsWith(const string &str, const string &suffix);
+
+	//! Repeat a string multiple times
+	DUCKDB_API static string Repeat(const string &str, const idx_t n);
+
+	//! Split the input string based on newline char
+	DUCKDB_API static vector<string> Split(const string &str, char delimiter);
+
+	//! Split the input string allong a quote. Note that any escaping is NOT supported.
+	DUCKDB_API static vector<string> SplitWithQuote(const string &str, char delimiter = ',', char quote = '"');
+
+	//! Join multiple strings into one string. Components are concatenated by the given separator
+	DUCKDB_API static string Join(const vector<string> &input, const string &separator);
+
+	//! Join multiple items of container with given size, transformed to string
+	//! using function, into one string using the given separator
+	template <typename C, typename S, typename Func>
+	static string Join(const C &input, S count, const string &separator, Func f) {
+		// The result
+		std::string result;
+
+		// If the input isn't empty, append the first element. We do this so we
+		// don't need to introduce an if into the loop.
+		if (count > 0) {
+			result += f(input[0]);
+		}
+
+		// Append the remaining input components, after the first
+		for (size_t i = 1; i < count; i++) {
+			result += separator + f(input[i]);
+		}
+
+		return result;
+	}
+
+	//! Return a string that formats the give number of bytes
+	DUCKDB_API static string BytesToHumanReadableString(idx_t bytes);
+
+	//! Convert a string to uppercase
+	DUCKDB_API static string Upper(const string &str);
+
+	//! Convert a string to lowercase
+	DUCKDB_API static string Lower(const string &str);
+
+	//! Format a string using printf semantics
+	template <typename... Args>
+	static string Format(const string fmt_str, Args... params) {
+		return Exception::ConstructMessage(fmt_str, params...);
+	}
+
+	//! Split the input string into a vector of strings based on the split string
+	DUCKDB_API static vector<string> Split(const string &input, const string &split);
+
+	//! Remove the whitespace char in the left end of the string
+	DUCKDB_API static void LTrim(string &str);
+	//! Remove the whitespace char in the right end of the string
+	DUCKDB_API static void RTrim(string &str);
+	//! Remove the whitespace char in the left and right end of the string
+	DUCKDB_API static void Trim(string &str);
+
+	DUCKDB_API static string Replace(string source, const string &from, const string &to);
+
+	//! Get the levenshtein distance from two strings
+	DUCKDB_API static idx_t LevenshteinDistance(const string &s1, const string &s2);
+
+	//! Get the top-n strings (sorted by the given score distance) from a set of scores.
+	//! At least one entry is returned (if there is one).
+	//! Strings are only returned if they have a score less than the threshold.
+	DUCKDB_API static vector<string> TopNStrings(vector<std::pair<string, idx_t>> scores, idx_t n = 5,
+	                                             idx_t threshold = 5);
+	//! Computes the levenshtein distance of each string in strings, and compares it to target, then returns TopNStrings
+	//! with the given params.
+	DUCKDB_API static vector<string> TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n = 5,
+	                                                 idx_t threshold = 5);
+	DUCKDB_API static string CandidatesMessage(const vector<string> &candidates,
+	                                           const string &candidate = "Candidate bindings");
+
+	//! Generate an error message in the form of "{message_prefix}: nearest_string, nearest_string2, ...
+	//! Equivalent to calling TopNLevenshtein followed by CandidatesMessage
+	DUCKDB_API static string CandidatesErrorMessage(const vector<string> &strings, const string &target,
+	                                                const string &message_prefix, idx_t n = 5);
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+struct CaseInsensitiveStringHashFunction {
+	uint64_t operator()(const string &str) const {
+		std::hash<string> hasher;
+		return hasher(StringUtil::Lower(str));
+	}
+};
+
+struct CaseInsensitiveStringEquality {
+	bool operator()(const string &a, const string &b) const {
+		return StringUtil::Lower(a) == StringUtil::Lower(b);
+	}
+};
+
+template <typename T>
+using case_insensitive_map_t =
+    unordered_map<string, T, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
+
+using case_insensitive_set_t = unordered_set<string, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+using named_parameter_type_map_t = case_insensitive_map_t<LogicalType>;
+using named_parameter_map_t = case_insensitive_map_t<Value>;
+
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/column_definition.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/base_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/expression_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Predicate Expression Operation Types
+//===--------------------------------------------------------------------===//
+enum class ExpressionType : uint8_t {
+	INVALID = 0,
+
+	// explicitly cast left as right (right is integer in ValueType enum)
+	OPERATOR_CAST = 12,
+	// logical not operator
+	OPERATOR_NOT = 13,
+	// is null operator
+	OPERATOR_IS_NULL = 14,
+	// is not null operator
+	OPERATOR_IS_NOT_NULL = 15,
+
+	// -----------------------------
+	// Comparison Operators
+	// -----------------------------
+	// equal operator between left and right
+	COMPARE_EQUAL = 25,
+	// compare initial boundary
+	COMPARE_BOUNDARY_START = COMPARE_EQUAL,
+	// inequal operator between left and right
+	COMPARE_NOTEQUAL = 26,
+	// less than operator between left and right
 	COMPARE_LESSTHAN = 27,
 	// greater than operator between left and right
 	COMPARE_GREATERTHAN = 28,
@@ -5598,6 +5982,8 @@ public:
 namespace duckdb {
 class Serializer;
 class Deserializer;
+class FieldWriter;
+class FieldReader;
 
 //!  The ParsedExpression class is a base class that can represent any expression
 //!  part of a SQL statement.
@@ -5631,7 +6017,10 @@ public:
 	virtual unique_ptr<ParsedExpression> Copy() const = 0;
 
 	//! Serializes an Expression to a stand-alone binary blob
-	virtual void Serialize(Serializer &serializer);
+	void Serialize(Serializer &serializer) const;
+	//! Serializes an Expression to a stand-alone binary blob
+	virtual void Serialize(FieldWriter &writer) const = 0;
+
 	//! Deserializes a blob back into an Expression [CAN THROW:
 	//! SerializationException]
 	static unique_ptr<ParsedExpression> Deserialize(Deserializer &source);
@@ -5742,7 +6131,7 @@ struct TableFunctionData : public FunctionData {
 
 struct FunctionParameters {
 	vector<Value> values;
-	unordered_map<string, Value> named_parameters;
+	named_parameter_map_t named_parameters;
 };
 
 //! Function is the base class used for any type of function (scalar, aggregate or simple function)
@@ -5762,7 +6151,7 @@ public:
 	                                      const LogicalType &return_type);
 	//! Returns the formatted string name(arg1, arg2.., np1=a, np2=b, ...)
 	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
-	                                      const unordered_map<string, LogicalType> &named_parameters);
+	                                      const named_parameter_type_map_t &named_parameters);
 
 	//! Bind a scalar function from the set of functions and input arguments. Returns the index of the chosen function,
 	//! returns DConstants::INVALID_INDEX and sets error if none could be found
@@ -5812,14 +6201,14 @@ public:
 	DUCKDB_API ~SimpleNamedParameterFunction() override;
 
 	//! The named parameters of the function
-	unordered_map<string, LogicalType> named_parameters;
+	named_parameter_type_map_t named_parameters;
 
 public:
 	DUCKDB_API string ToString() override;
 	DUCKDB_API bool HasNamedParameters();
 
 	DUCKDB_API void EvaluateInputParameters(vector<LogicalType> &arguments, vector<Value> &parameters,
-	                                        unordered_map<string, Value> &named_parameters,
+	                                        named_parameter_map_t &named_parameters,
 	                                        vector<unique_ptr<ParsedExpression>> &children);
 };
 
@@ -6511,6 +6900,8 @@ struct SelectionVector;
 
 class Serializer;
 class Deserializer;
+class FieldWriter;
+class FieldReader;
 class Vector;
 class ValidityStatistics;
 
@@ -6525,24 +6916,27 @@ public:
 	unique_ptr<BaseStatistics> validity_stats;
 
 public:
-	bool CanHaveNull();
-	bool CanHaveNoNull();
+	bool CanHaveNull() const;
+	bool CanHaveNoNull() const;
 
-	virtual bool IsConstant() {
+	virtual bool IsConstant() const {
 		return false;
 	}
 
 	static unique_ptr<BaseStatistics> CreateEmpty(LogicalType type);
 
 	virtual void Merge(const BaseStatistics &other);
-	virtual unique_ptr<BaseStatistics> Copy();
-	virtual void Serialize(Serializer &serializer);
+
+	virtual unique_ptr<BaseStatistics> Copy() const;
+	void Serialize(Serializer &serializer) const;
+	virtual void Serialize(FieldWriter &writer) const;
 	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
+
 	//! Verify that a vector does not violate the statistics
-	virtual void Verify(Vector &vector, const SelectionVector &sel, idx_t count);
-	void Verify(Vector &vector, idx_t count);
+	virtual void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
+	void Verify(Vector &vector, idx_t count) const;
 
-	virtual string ToString();
+	virtual string ToString() const;
 };
 
 } // namespace duckdb
@@ -7167,6 +7561,8 @@ enum class OrderByNullType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, NULLS_FIR
 
 
 namespace duckdb {
+class FieldWriter;
+class FieldReader;
 
 enum ResultModifierType : uint8_t {
 	LIMIT_MODIFIER = 1,
@@ -7190,9 +7586,11 @@ public:
 	virtual bool Equals(const ResultModifier *other) const;
 
 	//! Create a copy of this ResultModifier
-	virtual unique_ptr<ResultModifier> Copy() = 0;
+	virtual unique_ptr<ResultModifier> Copy() const = 0;
 	//! Serializes a ResultModifier to a stand-alone binary blob
-	virtual void Serialize(Serializer &serializer);
+	void Serialize(Serializer &serializer) const;
+	//! Serializes a ResultModifier to a stand-alone binary blob
+	virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a ResultModifier
 	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
 };
@@ -7211,7 +7609,7 @@ struct OrderByNode {
 	unique_ptr<ParsedExpression> expression;
 
 public:
-	void Serialize(Serializer &serializer);
+	void Serialize(Serializer &serializer) const;
 	string ToString() const;
 	static OrderByNode Deserialize(Deserializer &source);
 };
@@ -7228,9 +7626,9 @@ public:
 
 public:
 	bool Equals(const ResultModifier *other) const override;
-	unique_ptr<ResultModifier> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
+	unique_ptr<ResultModifier> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
 };
 
 class OrderModifier : public ResultModifier {
@@ -7243,9 +7641,9 @@ public:
 
 public:
 	bool Equals(const ResultModifier *other) const override;
-	unique_ptr<ResultModifier> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
+	unique_ptr<ResultModifier> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
 };
 
 class DistinctModifier : public ResultModifier {
@@ -7258,9 +7656,9 @@ public:
 
 public:
 	bool Equals(const ResultModifier *other) const override;
-	unique_ptr<ResultModifier> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
+	unique_ptr<ResultModifier> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
 };
 
 class LimitPercentModifier : public ResultModifier {
@@ -7275,9 +7673,9 @@ public:
 
 public:
 	bool Equals(const ResultModifier *other) const override;
-	unique_ptr<ResultModifier> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
+	unique_ptr<ResultModifier> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
 };
 
 } // namespace duckdb
@@ -9638,8 +10036,6 @@ public:
 
 
 
-
-
 #include <functional>
 
 namespace duckdb {
@@ -9659,7 +10055,7 @@ struct TableFilterCollection {
 };
 
 typedef unique_ptr<FunctionData> (*table_function_bind_t)(ClientContext &context, vector<Value> &inputs,
-                                                          unordered_map<string, Value> &named_parameters,
+                                                          named_parameter_map_t &named_parameters,
                                                           vector<LogicalType> &input_table_types,
                                                           vector<string> &input_table_names,
                                                           vector<LogicalType> &return_types, vector<string> &names);
@@ -10462,6 +10858,9 @@ public:
 	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,
 	                                     JoinType type = JoinType::INNER);
 
+	// CROSS PRODUCT operation
+	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other);
+
 	// SET operations
 	DUCKDB_API shared_ptr<Relation> Union(const shared_ptr<Relation> &other);
 	DUCKDB_API shared_ptr<Relation> Except(const shared_ptr<Relation> &other);
@@ -10499,7 +10898,7 @@ public:
 	//! Create a relation from calling a table in/out function on the input relation
 	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values);
 	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values,
-	                                              const unordered_map<string, Value> &named_parameters);
+	                                              const named_parameter_map_t &named_parameters);
 
 public:
 	//! Whether or not the relation inherits column bindings from its child or not, only relevant for binding
@@ -10656,6 +11055,9 @@ public:
 	//! The query text that corresponds to this SQL statement
 	string query;
 
+protected:
+	SQLStatement(const SQLStatement &other) = default;
+
 public:
 	//! Create a copy of this SelectStatement
 	virtual unique_ptr<SQLStatement> Copy() const = 0;
@@ -10670,6 +11072,7 @@ class ClientContext;
 class DatabaseInstance;
 class DuckDB;
 class LogicalOperator;
+class SelectStatement;
 
 typedef void (*warning_callback)(std::string);
 
@@ -10756,7 +11159,7 @@ public:
 	//! Returns a relation that calls a specified table function
 	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname);
 	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values,
-	                                              const unordered_map<string, Value> &named_parameters);
+	                                              const named_parameter_map_t &named_parameters);
 	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values);
 	//! Returns a relation that produces values
 	DUCKDB_API shared_ptr<Relation> Values(const vector<vector<Value>> &values);
@@ -10769,7 +11172,10 @@ public:
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file);
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, const vector<string> &columns);
 	//! Returns a relation from a query
-	DUCKDB_API shared_ptr<Relation> RelationFromQuery(const string &query, const string &alias = "queryrelation");
+	DUCKDB_API shared_ptr<Relation> RelationFromQuery(const string &query, string alias = "queryrelation",
+	                                                  const string &error = "Expected a single SELECT statement");
+	DUCKDB_API shared_ptr<Relation> RelationFromQuery(unique_ptr<SelectStatement> select_stmt,
+	                                                  string alias = "queryrelation");
 
 	DUCKDB_API void BeginTransaction();
 	DUCKDB_API void Commit();
@@ -10967,10 +11373,17 @@ private:
 
 } // namespace duckdb
 
+
+
+
+
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/case_insensitive_map.hpp
+// duckdb/function/replacement_scan.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -10979,222 +11392,48 @@ private:
 
 
 
+namespace duckdb {
+
+class TableFunctionRef;
+
+typedef unique_ptr<TableFunctionRef> (*replacement_scan_t)(const string &table_name, void *data);
+
+//! Replacement table scans are automatically attempted when a table name cannot be found in the schema
+//! This allows you to do e.g. SELECT * FROM 'filename.csv', and automatically convert this into a CSV scan
+struct ReplacementScan {
+	explicit ReplacementScan(replacement_scan_t function, void *data = nullptr) : function(function), data(data) {
+	}
+
+	replacement_scan_t function;
+	void *data;
+};
+
+} // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/string_util.hpp
+// duckdb/common/set.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
-
-
-
-
-
-namespace duckdb {
-/**
- * String Utility Functions
- * Note that these are not the most efficient implementations (i.e., they copy
- * memory) and therefore they should only be used for debug messages and other
- * such things.
- */
-class StringUtil {
-public:
-	DUCKDB_API static bool CharacterIsSpace(char c) {
-		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
-	}
-	DUCKDB_API static bool CharacterIsNewline(char c) {
-		return c == '\n' || c == '\r';
-	}
-	DUCKDB_API static bool CharacterIsDigit(char c) {
-		return c >= '0' && c <= '9';
-	}
-	DUCKDB_API static char CharacterToLower(char c) {
-		if (c >= 'A' && c <= 'Z') {
-			return c - ('A' - 'a');
-		}
-		return c;
-	}
-
-	//! Returns true if the needle string exists in the haystack
-	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
-
-	//! Returns true if the target string starts with the given prefix
-	DUCKDB_API static bool StartsWith(string str, string prefix);
-
-	//! Returns true if the target string <b>ends</b> with the given suffix.
-	DUCKDB_API static bool EndsWith(const string &str, const string &suffix);
-
-	//! Repeat a string multiple times
-	DUCKDB_API static string Repeat(const string &str, const idx_t n);
-
-	//! Split the input string based on newline char
-	DUCKDB_API static vector<string> Split(const string &str, char delimiter);
-
-	//! Split the input string allong a quote. Note that any escaping is NOT supported.
-	DUCKDB_API static vector<string> SplitWithQuote(const string &str, char delimiter = ',', char quote = '"');
-
-	//! Join multiple strings into one string. Components are concatenated by the given separator
-	DUCKDB_API static string Join(const vector<string> &input, const string &separator);
-
-	//! Join multiple items of container with given size, transformed to string
-	//! using function, into one string using the given separator
-	template <typename C, typename S, typename Func>
-	static string Join(const C &input, S count, const string &separator, Func f) {
-		// The result
-		std::string result;
-
-		// If the input isn't empty, append the first element. We do this so we
-		// don't need to introduce an if into the loop.
-		if (count > 0) {
-			result += f(input[0]);
-		}
-
-		// Append the remaining input components, after the first
-		for (size_t i = 1; i < count; i++) {
-			result += separator + f(input[i]);
-		}
-
-		return result;
-	}
-
-	//! Return a string that formats the give number of bytes
-	DUCKDB_API static string BytesToHumanReadableString(idx_t bytes);
-
-	//! Convert a string to uppercase
-	DUCKDB_API static string Upper(const string &str);
-
-	//! Convert a string to lowercase
-	DUCKDB_API static string Lower(const string &str);
-
-	//! Format a string using printf semantics
-	template <typename... Args>
-	static string Format(const string fmt_str, Args... params) {
-		return Exception::ConstructMessage(fmt_str, params...);
-	}
-
-	//! Split the input string into a vector of strings based on the split string
-	DUCKDB_API static vector<string> Split(const string &input, const string &split);
-
-	//! Remove the whitespace char in the left end of the string
-	DUCKDB_API static void LTrim(string &str);
-	//! Remove the whitespace char in the right end of the string
-	DUCKDB_API static void RTrim(string &str);
-	//! Remove the whitespace char in the left and right end of the string
-	DUCKDB_API static void Trim(string &str);
-
-	DUCKDB_API static string Replace(string source, const string &from, const string &to);
-
-	//! Get the levenshtein distance from two strings
-	DUCKDB_API static idx_t LevenshteinDistance(const string &s1, const string &s2);
-
-	//! Get the top-n strings (sorted by the given score distance) from a set of scores.
-	//! At least one entry is returned (if there is one).
-	//! Strings are only returned if they have a score less than the threshold.
-	DUCKDB_API static vector<string> TopNStrings(vector<std::pair<string, idx_t>> scores, idx_t n = 5,
-	                                             idx_t threshold = 5);
-	//! Computes the levenshtein distance of each string in strings, and compares it to target, then returns TopNStrings
-	//! with the given params.
-	DUCKDB_API static vector<string> TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n = 5,
-	                                                 idx_t threshold = 5);
-	DUCKDB_API static string CandidatesMessage(const vector<string> &candidates,
-	                                           const string &candidate = "Candidate bindings");
-
-	//! Generate an error message in the form of "{message_prefix}: nearest_string, nearest_string2, ...
-	//! Equivalent to calling TopNLevenshtein followed by CandidatesMessage
-	DUCKDB_API static string CandidatesErrorMessage(const vector<string> &strings, const string &target,
-	                                                const string &message_prefix, idx_t n = 5);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct CaseInsensitiveStringHashFunction {
-	uint64_t operator()(const string &str) const {
-		std::hash<string> hasher;
-		return hasher(StringUtil::Lower(str));
-	}
-};
-
-struct CaseInsensitiveStringEquality {
-	bool operator()(const string &a, const string &b) const {
-		return StringUtil::Lower(a) == StringUtil::Lower(b);
-	}
-};
-
-template <typename T>
-using case_insensitive_map_t =
-    unordered_map<string, T, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
-
-using case_insensitive_set_t = unordered_set<string, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
-
-} // namespace duckdb
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/replacement_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class TableFunctionRef;
-
-typedef unique_ptr<TableFunctionRef> (*replacement_scan_t)(const string &table_name, void *data);
-
-//! Replacement table scans are automatically attempted when a table name cannot be found in the schema
-//! This allows you to do e.g. SELECT * FROM 'filename.csv', and automatically convert this into a CSV scan
-struct ReplacementScan {
-	explicit ReplacementScan(replacement_scan_t function, void *data = nullptr) : function(function), data(data) {
-	}
-
-	replacement_scan_t function;
-	void *data;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <set>
-
-namespace duckdb {
-using std::set;
-}
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/optimizer_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
+
+#include <set>
+
+namespace duckdb {
+using std::set;
+}
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/optimizer_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
 
 
@@ -11455,17 +11694,17 @@ public:
 	DBConfig config;
 
 public:
-	StorageManager &GetStorageManager();
-	Catalog &GetCatalog();
-	FileSystem &GetFileSystem();
-	TransactionManager &GetTransactionManager();
-	TaskScheduler &GetScheduler();
-	ObjectCache &GetObjectCache();
-	ConnectionManager &GetConnectionManager();
+	DUCKDB_API StorageManager &GetStorageManager();
+	DUCKDB_API Catalog &GetCatalog();
+	DUCKDB_API FileSystem &GetFileSystem();
+	DUCKDB_API TransactionManager &GetTransactionManager();
+	DUCKDB_API TaskScheduler &GetScheduler();
+	DUCKDB_API ObjectCache &GetObjectCache();
+	DUCKDB_API ConnectionManager &GetConnectionManager();
 
 	idx_t NumberOfThreads();
 
-	static DatabaseInstance &GetDatabase(ClientContext &context);
+	DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context);
 
 private:
 	void Initialize(const char *path, DBConfig *config);
@@ -12775,7 +13014,9 @@ public:
 	//! contains January 4 of that year.
 	//! In the ISO week-numbering system, it is possible for early-January dates
 	//! to be part of the 52nd or 53rd week of the previous year.
+	DUCKDB_API static void ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week);
 	DUCKDB_API static int32_t ExtractISOWeekNumber(date_t date);
+	DUCKDB_API static int32_t ExtractISOYearNumber(date_t date);
 	//! Extract the week number as Python handles it.
 	//! Either Monday or Sunday is the first day of the week,
 	//! and any date before the first Monday/Sunday returns week 0
@@ -12797,112 +13038,29 @@ private:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/arrow.hpp
+// duckdb/common/types/blob.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef ARROW_FLAG_DICTIONARY_ORDERED
-
-#include <stdint.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 
-#define ARROW_FLAG_DICTIONARY_ORDERED 1
-#define ARROW_FLAG_NULLABLE           2
-#define ARROW_FLAG_MAP_KEYS_SORTED    4
 
-struct ArrowSchema {
-	// Array type description
-	const char *format;
-	const char *name;
-	const char *metadata;
-	int64_t flags;
-	int64_t n_children;
-	struct ArrowSchema **children;
-	struct ArrowSchema *dictionary;
 
-	// Release callback
-	void (*release)(struct ArrowSchema *);
-	// Opaque producer-specific data
-	void *private_data;
-};
 
-struct ArrowArray {
-	// Array data description
-	int64_t length;
-	int64_t null_count;
-	int64_t offset;
-	int64_t n_buffers;
-	int64_t n_children;
-	const void **buffers;
-	struct ArrowArray **children;
-	struct ArrowArray *dictionary;
+namespace duckdb {
 
-	// Release callback
-	void (*release)(struct ArrowArray *);
-	// Opaque producer-specific data
-	void *private_data;
-};
-
-// EXPERIMENTAL
-struct ArrowArrayStream {
-	// Callback to get the stream type
-	// (will be the same for all arrays in the stream).
-	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
-	int (*get_schema)(struct ArrowArrayStream *, struct ArrowSchema *out);
-	// Callback to get the next array
-	// (if no error and the array is released, the stream has ended)
-	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
-	int (*get_next)(struct ArrowArrayStream *, struct ArrowArray *out);
-
-	// Callback to get optional detailed error information.
-	// This must only be called if the last stream operation failed
-	// with a non-0 return code.  The returned pointer is only valid until
-	// the next operation on this stream (including release).
-	// If unavailable, NULL is returned.
-	const char *(*get_last_error)(struct ArrowArrayStream *);
-
-	// Release callback: release the stream's own resources.
-	// Note that arrays returned by `get_next` must be individually released.
-	void (*release)(struct ArrowArrayStream *);
-	// Opaque producer-specific data
-	void *private_data;
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/blob.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! The Blob class is a static class that holds helper functions for the Blob type.
-class Blob {
-public:
-	// map of integer -> hex value
-	static constexpr const char *HEX_TABLE = "0123456789ABCDEF";
-	// reverse map of byte -> integer value, or -1 for invalid hex values
-	static const int HEX_MAP[256];
-	//! map of index -> base64 character
-	static constexpr const char *BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-	//! padding character used in base64 encoding
-	static constexpr const char BASE64_PADDING = '=';
+//! The Blob class is a static class that holds helper functions for the Blob type.
+class Blob {
+public:
+	// map of integer -> hex value
+	static constexpr const char *HEX_TABLE = "0123456789ABCDEF";
+	// reverse map of byte -> integer value, or -1 for invalid hex values
+	static const int HEX_MAP[256];
+	//! map of index -> base64 character
+	static constexpr const char *BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	//! padding character used in base64 encoding
+	static constexpr const char BASE64_PADDING = '=';
 
 public:
 	//! Returns the string size of a blob -> string conversion
@@ -13480,6 +13638,8 @@ namespace duckdb {
 
 class Serializer;
 class Deserializer;
+class FieldWriter;
+class FieldReader;
 
 //===--------------------------------------------------------------------===//
 // Constraint Types
@@ -13502,13 +13662,14 @@ public:
 
 public:
 	DUCKDB_API virtual string ToString() const = 0;
-	DUCKDB_API void Print();
+	DUCKDB_API void Print() const;
 
-	DUCKDB_API virtual unique_ptr<Constraint> Copy() = 0;
+	DUCKDB_API virtual unique_ptr<Constraint> Copy() const = 0;
 	//! Serializes a Constraint to a stand-alone binary blob
-	DUCKDB_API virtual void Serialize(Serializer &serializer);
-	//! Deserializes a blob back into a Constraint, returns NULL if
-	//! deserialization is not possible
+	DUCKDB_API void Serialize(Serializer &serializer) const;
+	//! Serializes a Constraint to a stand-alone binary blob
+	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
+	//! Deserializes a blob back into a Constraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
 };
 } // namespace duckdb
@@ -13779,10 +13940,8 @@ enum class AlterType : uint8_t {
 };
 
 struct AlterInfo : public ParseInfo {
-	AlterInfo(AlterType type, string schema, string name) : type(type), schema(move(schema)), name(move(name)) {
-	}
-	~AlterInfo() override {
-	}
+	AlterInfo(AlterType type, string schema, string name);
+	~AlterInfo() override;
 
 	AlterType type;
 	//! Schema name to alter
@@ -13791,9 +13950,10 @@ struct AlterInfo : public ParseInfo {
 	string name;
 
 public:
-	virtual CatalogType GetCatalogType() = 0;
+	virtual CatalogType GetCatalogType() const = 0;
 	virtual unique_ptr<AlterInfo> Copy() const = 0;
-	virtual void Serialize(Serializer &serializer);
+	void Serialize(Serializer &serializer) const;
+	virtual void Serialize(FieldWriter &writer) const = 0;
 	static unique_ptr<AlterInfo> Deserialize(Deserializer &source);
 };
 
@@ -13802,10 +13962,7 @@ public:
 //===--------------------------------------------------------------------===//
 struct ChangeOwnershipInfo : public AlterInfo {
 	ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_schema, string entry_name, string owner_schema,
-	                    string owner_name)
-	    : AlterInfo(AlterType::CHANGE_OWNERSHIP, entry_schema, entry_name), entry_catalog_type(entry_catalog_type),
-	      owner_schema(owner_schema), owner_name(owner_name) {
-	}
+	                    string owner_name);
 
 	// Catalog type refers to the entry type, since this struct is usually built from an
 	// ALTER <TYPE> <schema>.<name> OWNED BY <owner_schema>.<owner_name> statement
@@ -13816,8 +13973,9 @@ struct ChangeOwnershipInfo : public AlterInfo {
 	string owner_name;
 
 public:
-	CatalogType GetCatalogType() override;
+	CatalogType GetCatalogType() const override;
 	unique_ptr<AlterInfo> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
 };
 
 //===--------------------------------------------------------------------===//
@@ -13834,32 +13992,24 @@ enum class AlterTableType : uint8_t {
 };
 
 struct AlterTableInfo : public AlterInfo {
-	AlterTableInfo(AlterTableType type, string schema, string table)
-	    : AlterInfo(AlterType::ALTER_TABLE, schema, table), alter_table_type(type) {
-	}
-	~AlterTableInfo() override {
-	}
+	AlterTableInfo(AlterTableType type, string schema, string table);
+	~AlterTableInfo() override;
 
 	AlterTableType alter_table_type;
 
 public:
-	CatalogType GetCatalogType() override {
-		return CatalogType::TABLE_ENTRY;
-	}
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source);
+	CatalogType GetCatalogType() const override;
+	void Serialize(FieldWriter &writer) const override;
+	virtual void SerializeAlterTable(FieldWriter &writer) const = 0;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
 };
 
 //===--------------------------------------------------------------------===//
 // RenameColumnInfo
 //===--------------------------------------------------------------------===//
 struct RenameColumnInfo : public AlterTableInfo {
-	RenameColumnInfo(string schema, string table, string old_name_p, string new_name_p)
-	    : AlterTableInfo(AlterTableType::RENAME_COLUMN, move(schema), move(table)), old_name(move(old_name_p)),
-	      new_name(move(new_name_p)) {
-	}
-	~RenameColumnInfo() override {
-	}
+	RenameColumnInfo(string schema, string table, string old_name_p, string new_name_p);
+	~RenameColumnInfo() override;
 
 	//! Column old name
 	string old_name;
@@ -13868,58 +14018,48 @@ struct RenameColumnInfo : public AlterTableInfo {
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source, string schema, string table);
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
 };
 
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
 struct RenameTableInfo : public AlterTableInfo {
-	RenameTableInfo(string schema, string table, string new_name)
-	    : AlterTableInfo(AlterTableType::RENAME_TABLE, schema, table), new_table_name(new_name) {
-	}
-	~RenameTableInfo() override {
-	}
+	RenameTableInfo(string schema, string table, string new_name);
+	~RenameTableInfo() override;
 
 	//! Relation new name
 	string new_table_name;
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source, string schema, string table);
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
 };
 
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
 struct AddColumnInfo : public AlterTableInfo {
-	AddColumnInfo(string schema, string table, ColumnDefinition new_column)
-	    : AlterTableInfo(AlterTableType::ADD_COLUMN, schema, table), new_column(move(new_column)) {
-	}
-	~AddColumnInfo() override {
-	}
+	AddColumnInfo(string schema, string table, ColumnDefinition new_column);
+	~AddColumnInfo() override;
 
 	//! New column
 	ColumnDefinition new_column;
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source, string schema, string table);
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
 };
 
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
 struct RemoveColumnInfo : public AlterTableInfo {
-	RemoveColumnInfo(string schema, string table, string removed_column, bool if_exists)
-	    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, schema, table), removed_column(move(removed_column)),
-	      if_exists(if_exists) {
-	}
-	~RemoveColumnInfo() override {
-	}
+	RemoveColumnInfo(string schema, string table, string removed_column, bool if_exists);
+	~RemoveColumnInfo() override;
 
 	//! The column to remove
 	string removed_column;
@@ -13928,8 +14068,8 @@ struct RemoveColumnInfo : public AlterTableInfo {
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source, string schema, string table);
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
 };
 
 //===--------------------------------------------------------------------===//
@@ -13937,12 +14077,8 @@ public:
 //===--------------------------------------------------------------------===//
 struct ChangeColumnTypeInfo : public AlterTableInfo {
 	ChangeColumnTypeInfo(string schema, string table, string column_name, LogicalType target_type,
-	                     unique_ptr<ParsedExpression> expression)
-	    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, schema, table), column_name(move(column_name)),
-	      target_type(move(target_type)), expression(move(expression)) {
-	}
-	~ChangeColumnTypeInfo() override {
-	}
+	                     unique_ptr<ParsedExpression> expression);
+	~ChangeColumnTypeInfo() override;
 
 	//! The column name to alter
 	string column_name;
@@ -13953,20 +14089,16 @@ struct ChangeColumnTypeInfo : public AlterTableInfo {
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source, string schema, string table);
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
 };
 
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
 struct SetDefaultInfo : public AlterTableInfo {
-	SetDefaultInfo(string schema, string table, string column_name, unique_ptr<ParsedExpression> new_default)
-	    : AlterTableInfo(AlterTableType::SET_DEFAULT, schema, table), column_name(move(column_name)),
-	      expression(move(new_default)) {
-	}
-	~SetDefaultInfo() override {
-	}
+	SetDefaultInfo(string schema, string table, string column_name, unique_ptr<ParsedExpression> new_default);
+	~SetDefaultInfo() override;
 
 	//! The column name to alter
 	string column_name;
@@ -13975,8 +14107,8 @@ struct SetDefaultInfo : public AlterTableInfo {
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source, string schema, string table);
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
 };
 
 //===--------------------------------------------------------------------===//
@@ -13985,39 +14117,32 @@ public:
 enum class AlterViewType : uint8_t { INVALID = 0, RENAME_VIEW = 1 };
 
 struct AlterViewInfo : public AlterInfo {
-	AlterViewInfo(AlterViewType type, string schema, string view)
-	    : AlterInfo(AlterType::ALTER_VIEW, schema, view), alter_view_type(type) {
-	}
-	~AlterViewInfo() override {
-	}
+	AlterViewInfo(AlterViewType type, string schema, string view);
+	~AlterViewInfo() override;
 
 	AlterViewType alter_view_type;
 
 public:
-	CatalogType GetCatalogType() override {
-		return CatalogType::VIEW_ENTRY;
-	}
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source);
+	CatalogType GetCatalogType() const override;
+	void Serialize(FieldWriter &writer) const override;
+	virtual void SerializeAlterView(FieldWriter &writer) const = 0;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
 };
 
 //===--------------------------------------------------------------------===//
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
 struct RenameViewInfo : public AlterViewInfo {
-	RenameViewInfo(string schema, string view, string new_name)
-	    : AlterViewInfo(AlterViewType::RENAME_VIEW, schema, view), new_view_name(new_name) {
-	}
-	~RenameViewInfo() override {
-	}
+	RenameViewInfo(string schema, string view, string new_name);
+	~RenameViewInfo() override;
 
 	//! Relation new name
 	string new_view_name;
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source, string schema, string table);
+	void SerializeAlterView(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
 };
 
 } // namespace duckdb
@@ -15103,8 +15228,8 @@ public:
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 
@@ -15338,6 +15463,10 @@ public:
 	unique_ptr<ParsedExpression> Copy() const override {
 		throw SerializationException("Cannot copy or serialize bound expression");
 	}
+
+	void Serialize(FieldWriter &writer) const override {
+		throw SerializationException("Cannot copy or serialize bound expression");
+	}
 };
 
 } // namespace duckdb
@@ -15782,7 +15911,7 @@ public:
 	SchemaCatalogEntry *BindCreateFunctionInfo(CreateInfo &info);
 
 	//! Check usage, and cast named parameters to their types
-	static void BindNamedParameters(unordered_map<string, LogicalType> &types, unordered_map<string, Value> &values,
+	static void BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
 	                                QueryErrorContext &error_context, string &func_name);
 
 	unique_ptr<BoundTableRef> Bind(TableRef &ref);
@@ -15798,6 +15927,9 @@ public:
 
 	bool CTEIsAlreadyBound(CommonTableExpressionInfo *cte);
 
+	//! Add the view to the set of currently bound views - used for detecting recursive view definitions
+	void AddBoundView(ViewCatalogEntry *view);
+
 	void PushExpressionBinder(ExpressionBinder *binder);
 	void PopExpressionBinder();
 	void SetActiveBinder(ExpressionBinder *binder);
@@ -15859,6 +15991,8 @@ private:
 	BindingMode mode = BindingMode::STANDARD_BINDING;
 	//! Table names extracted for BindingMode::EXTRACT_NAMES
 	unordered_set<string> table_names;
+	//! The set of bound views
+	unordered_set<ViewCatalogEntry *> bound_views;
 
 private:
 	//! Bind the default values of the columns of a table
@@ -15909,7 +16043,7 @@ private:
 	unique_ptr<BoundTableRef> Bind(ExpressionListRef &ref);
 
 	bool BindFunctionParameters(vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
-	                            vector<Value> &parameters, unordered_map<string, Value> &named_parameters,
+	                            vector<Value> &parameters, named_parameter_map_t &named_parameters,
 	                            unique_ptr<BoundSubqueryRef> &subquery, string &error);
 
 	unique_ptr<LogicalOperator> CreatePlan(BoundBaseTableRef &ref);
@@ -16117,9 +16251,11 @@ public:
 	virtual unique_ptr<TableRef> Copy() = 0;
 
 	//! Serializes a TableRef to a stand-alone binary blob
-	virtual void Serialize(Serializer &serializer);
+	DUCKDB_API void Serialize(Serializer &serializer) const;
+	//! Serializes a TableRef to a stand-alone binary blob
+	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a TableRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+	DUCKDB_API static unique_ptr<TableRef> Deserialize(Deserializer &source);
 
 	//! Copy the properties of this table ref to the target
 	void CopyProperties(TableRef &target) const;
@@ -16140,11 +16276,14 @@ public:
 	//! The main query node
 	unique_ptr<QueryNode> node;
 
+protected:
+	SelectStatement(const SelectStatement &other);
+
 public:
 	//! Create a copy of this SelectStatement
 	unique_ptr<SQLStatement> Copy() const override;
 	//! Serializes a SelectStatement to a stand-alone binary blob
-	void Serialize(Serializer &serializer);
+	void Serialize(Serializer &serializer) const;
 	//! Deserializes a blob back into a SelectStatement, returns nullptr if
 	//! deserialization is not possible
 	static unique_ptr<SelectStatement> Deserialize(Deserializer &source);
@@ -16195,12 +16334,13 @@ public:
 	virtual bool Equals(const QueryNode *other) const;
 
 	//! Create a copy of this QueryNode
-	virtual unique_ptr<QueryNode> Copy() = 0;
+	virtual unique_ptr<QueryNode> Copy() const = 0;
 	//! Serializes a QueryNode to a stand-alone binary blob
-	virtual void Serialize(Serializer &serializer);
-	//! Deserializes a blob back into a QueryNode, returns nullptr if
-	//! deserialization is not possible
-	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
+	DUCKDB_API void Serialize(Serializer &serializer) const;
+	//! Serializes a QueryNode to a stand-alone binary blob
+	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
+	//! Deserializes a blob back into a QueryNode
+	DUCKDB_API static unique_ptr<QueryNode> Deserialize(Deserializer &source);
 
 protected:
 	//! Copy base QueryNode properties from another expression to this one,
@@ -16395,8 +16535,8 @@ public:
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 
@@ -17250,6 +17390,10 @@ struct ClientConfig {
 	//! The wait time before showing the progress bar
 	int wait_time = 2000;
 
+	//! Preserve identifier case while parsing.
+	//! If false, all unquoted identifiers are lower-cased (e.g. "MyTable" -> "mytable").
+	bool preserve_identifier_case = true;
+
 	// Whether or not aggressive query verification is enabled
 	bool query_verification_enabled = false;
 	//! Enable the running of optimizers
@@ -17294,6 +17438,7 @@ class ClientContextLock;
 struct CreateScalarFunctionInfo;
 class ScalarFunctionCatalogEntry;
 struct ActiveQueryContext;
+struct ParserOptions;
 
 //! The ClientContext holds information relevant to the current client session
 //! during execution
@@ -17411,6 +17556,9 @@ public:
 	//! Equivalent to CURRENT_SETTING(key) SQL function.
 	DUCKDB_API bool TryGetCurrentSetting(const std::string &key, Value &result);
 
+	//! Returns the parser options for this client context
+	DUCKDB_API ParserOptions GetParserOptions();
+
 	DUCKDB_API unique_ptr<DataChunk> Fetch(ClientContextLock &lock, StreamQueryResult &result);
 
 	//! Whether or not the given result object (streaming query result or pending query result) is active
@@ -18544,12 +18692,12 @@ public:
 public:
 	DUCKDB_API string ToString() const override;
 
-	DUCKDB_API unique_ptr<Constraint> Copy() override;
+	DUCKDB_API unique_ptr<Constraint> Copy() const override;
 
 	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) override;
+	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a NotNullConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
 };
 
 } // namespace duckdb
@@ -19728,7 +19876,7 @@ struct PragmaInfo : public ParseInfo {
 	//! Parameter list (if any)
 	vector<Value> parameters;
 	//! Named parameter list (if any)
-	unordered_map<string, Value> named_parameters;
+	named_parameter_map_t named_parameters;
 
 public:
 	unique_ptr<PragmaInfo> Copy() const {
@@ -19779,7 +19927,7 @@ public:
 
 	pragma_query_t query;
 	pragma_function_t function;
-	unordered_map<string, LogicalType> named_parameters;
+	named_parameter_type_map_t named_parameters;
 
 private:
 	PragmaFunction(string name, PragmaType pragma_type, pragma_query_t query, pragma_function_t function,
@@ -19848,12 +19996,16 @@ struct PGList;
 
 namespace duckdb {
 
+struct ParserOptions {
+	bool preserve_identifier_case = true;
+};
+
 //! The parser is responsible for parsing the query and converting it into a set
 //! of parsed statements. The parsed statements can then be converted into a
 //! plan and executed.
 class Parser {
 public:
-	Parser();
+	Parser(ParserOptions options = ParserOptions());
 
 	//! The parsed SQL statements from an invocation to ParseQuery.
 	vector<unique_ptr<SQLStatement>> statements;
@@ -19874,16 +20026,22 @@ public:
 	static vector<ParserKeyword> KeywordList();
 
 	//! Parses a list of expressions (i.e. the list found in a SELECT clause)
-	static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list);
+	static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list,
+	                                                                ParserOptions options = ParserOptions());
 	//! Parses a list as found in an ORDER BY expression (i.e. including optional ASCENDING/DESCENDING modifiers)
-	static vector<OrderByNode> ParseOrderList(const string &select_list);
+	static vector<OrderByNode> ParseOrderList(const string &select_list, ParserOptions options = ParserOptions());
 	//! Parses an update list (i.e. the list found in the SET clause of an UPDATE statement)
 	static void ParseUpdateList(const string &update_list, vector<string> &update_columns,
-	                            vector<unique_ptr<ParsedExpression>> &expressions);
+	                            vector<unique_ptr<ParsedExpression>> &expressions,
+	                            ParserOptions options = ParserOptions());
 	//! Parses a VALUES list (i.e. the list of expressions after a VALUES clause)
-	static vector<vector<unique_ptr<ParsedExpression>>> ParseValuesList(const string &value_list);
+	static vector<vector<unique_ptr<ParsedExpression>>> ParseValuesList(const string &value_list,
+	                                                                    ParserOptions options = ParserOptions());
 	//! Parses a column list (i.e. as found in a CREATE TABLE statement)
-	static vector<ColumnDefinition> ParseColumnList(const string &column_list);
+	static vector<ColumnDefinition> ParseColumnList(const string &column_list, ParserOptions options = ParserOptions());
+
+private:
+	ParserOptions options;
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -20093,17 +20251,17 @@ public:
 public:
 	void Merge(const BaseStatistics &other) override;
 
-	bool IsConstant() override;
+	bool IsConstant() const override;
 
-	unique_ptr<BaseStatistics> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) override;
+	unique_ptr<BaseStatistics> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader);
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
 
 	static unique_ptr<BaseStatistics> Combine(const unique_ptr<BaseStatistics> &lstats,
 	                                          const unique_ptr<BaseStatistics> &rstats);
 
-	string ToString() override;
+	string ToString() const override;
 };
 
 } // namespace duckdb
@@ -20133,14 +20291,14 @@ public:
 	void Update(const string_t &value);
 	void Merge(const BaseStatistics &other) override;
 
-	unique_ptr<BaseStatistics> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) override;
+	unique_ptr<BaseStatistics> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
 
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const string &value);
+	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const string &value) const;
 
-	string ToString() override;
+	string ToString() const override;
 };
 
 } // namespace duckdb
@@ -20221,20 +20379,20 @@ public:
 public:
 	void Merge(const BaseStatistics &other) override;
 
-	bool IsConstant() override;
+	bool IsConstant() const override;
 
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant);
+	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
 
-	unique_ptr<BaseStatistics> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) override;
+	unique_ptr<BaseStatistics> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
 
-	string ToString() override;
+	string ToString() const override;
 
 private:
 	template <class T>
-	void TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count);
+	void TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count) const;
 
 public:
 	template <class T>
@@ -20444,7 +20602,7 @@ struct StrfTimeFormat : public StrTimeFormat {
 	void FormatString(date_t date, int32_t data[7], char *target);
 	void FormatString(date_t date, dtime_t time, char *target);
 
-	static string Format(timestamp_t timestamp, const string &format);
+	DUCKDB_API static string Format(timestamp_t timestamp, const string &format);
 
 protected:
 	//! The variable-length specifiers. To determine total string size, these need to be checked.
@@ -20478,9 +20636,14 @@ public:
 		timestamp_t ToTimestamp();
 		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);
+
 	bool Parse(string_t str, ParseResult &result);
 
 	bool TryParseDate(string_t str, date_t &result, string &error_message);
@@ -20583,6 +20746,9 @@ struct BufferedCSVReaderOptions {
 	idx_t buffer_size = STANDARD_VECTOR_SIZE * 100;
 	//! Consider all columns to be of type varchar
 	bool all_varchar = false;
+	//! Maximum CSV line size: specified because if we reach this amount, we likely have wrong delimiters (default: 2MB)
+	idx_t maximum_line_size = 2097152;
+
 	//! The date format to use (if any is specified)
 	std::map<LogicalTypeId, StrpTimeFormat> date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
 	//! Whether or not a type format is specified
@@ -20599,8 +20765,6 @@ enum class ParserMode : uint8_t { PARSING = 0, SNIFFING_DIALECT = 1, SNIFFING_DA
 class BufferedCSVReader {
 	//! Initial buffer read size; can be extended for long lines
 	static constexpr idx_t INITIAL_BUFFER_SIZE = 16384;
-	//! Maximum CSV line size: specified because if we reach this amount, we likely have the wrong delimiters
-	static constexpr idx_t MAXIMUM_CSV_LINE_SIZE = 1048576;
 	ParserMode mode;
 
 public:
@@ -20783,73 +20947,6 @@ public:
 	string ToString(const string &column_name) override;
 };
 
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//! Here we have the internal duckdb classes that interact with Arrow's Internal Header (i.e., duckdb/commons/arrow.hpp)
-namespace duckdb {
-class ArrowSchemaWrapper {
-public:
-	ArrowSchema arrow_schema;
-
-	ArrowSchemaWrapper() {
-		arrow_schema.release = nullptr;
-	}
-
-	~ArrowSchemaWrapper();
-};
-class ArrowArrayWrapper {
-public:
-	ArrowArray arrow_array;
-	ArrowArrayWrapper() {
-		arrow_array.length = 0;
-		arrow_array.release = nullptr;
-	}
-	~ArrowArrayWrapper();
-};
-
-class ArrowArrayStreamWrapper {
-public:
-	ArrowArrayStream arrow_array_stream;
-	int64_t number_of_rows;
-	void GetSchema(ArrowSchemaWrapper &schema);
-
-	unique_ptr<ArrowArrayWrapper> GetNextChunk();
-
-	const char *GetError();
-
-	~ArrowArrayStreamWrapper();
-	ArrowArrayStreamWrapper() {
-		arrow_array_stream.release = nullptr;
-	}
-};
-
-class ResultArrowArrayStreamWrapper {
-public:
-	explicit ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result, idx_t approx_batch_size);
-	ArrowArrayStream stream;
-	unique_ptr<QueryResult> result;
-	std::string last_error;
-	idx_t vectors_per_chunk;
-
-private:
-	static int MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out);
-	static int MyStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *out);
-	static void MyStreamRelease(struct ArrowArrayStream *stream);
-	static const char *MyStreamGetLastError(struct ArrowArrayStream *stream);
-};
-
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -20933,7 +21030,7 @@ private:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/star_expression.hpp
+// duckdb/parser/expression/lambda_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -20945,33 +21042,32 @@ private:
 
 namespace duckdb {
 
-//! Represents a * expression in the SELECT clause
-class StarExpression : public ParsedExpression {
+//! LambdaExpression represents a lambda operator that can be used for e.g. mapping an expression to a list
+//! Lambda expressions are written in the form of "capture -> expr", e.g. "x -> x + 1"
+class LambdaExpression : public ParsedExpression {
 public:
-	StarExpression(string relation_name = string());
+	LambdaExpression(vector<string> parameters, unique_ptr<ParsedExpression> expression);
 
-	//! The relation name in case of tbl.*, or empty if this is a normal *
-	string relation_name;
-	//! List of columns to exclude from the STAR expression
-	case_insensitive_set_t exclude_list;
-	//! List of columns to replace with another expression
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
+	vector<string> parameters;
+	unique_ptr<ParsedExpression> expression;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const StarExpression *a, const StarExpression *b);
+	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
+	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/conjunction_expression.hpp
+// duckdb/parser/expression/case_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -20983,32 +21079,34 @@ public:
 
 namespace duckdb {
 
-//! Represents a conjunction (AND/OR)
-class ConjunctionExpression : public ParsedExpression {
+struct CaseCheck {
+	unique_ptr<ParsedExpression> when_expr;
+	unique_ptr<ParsedExpression> then_expr;
+};
+
+//! The CaseExpression represents a CASE expression in the query
+class CaseExpression : public ParsedExpression {
 public:
-	explicit ConjunctionExpression(ExpressionType type);
-	ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-	ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
+	CaseExpression();
 
-	vector<unique_ptr<ParsedExpression>> children;
+	vector<CaseCheck> case_checks;
+	unique_ptr<ParsedExpression> else_expr;
 
 public:
-	void AddExpression(unique_ptr<ParsedExpression> expr);
-
 	string ToString() const override;
 
-	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
+	static bool Equals(const CaseExpression *a, const CaseExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/collate_expression.hpp
+// duckdb/parser/expression/conjunction_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21017,33 +21115,35 @@ public:
 
 
 
+
 namespace duckdb {
 
-//! CollateExpression represents a COLLATE statement
-class CollateExpression : public ParsedExpression {
+//! Represents a conjunction (AND/OR)
+class ConjunctionExpression : public ParsedExpression {
 public:
-	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
+	explicit ConjunctionExpression(ExpressionType type);
+	ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
 
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The collation clause
-	string collation;
+	vector<unique_ptr<ParsedExpression>> children;
 
 public:
+	void AddExpression(unique_ptr<ParsedExpression> expr);
+
 	string ToString() const override;
 
-	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/subquery_expression.hpp
+// duckdb/parser/expression/function_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21055,44 +21155,47 @@ public:
 
 
 namespace duckdb {
-
-//! Represents a subquery
-class SubqueryExpression : public ParsedExpression {
+//! Represents a function call
+class FunctionExpression : public ParsedExpression {
 public:
-	SubqueryExpression();
+	FunctionExpression(string schema_name, const string &function_name, vector<unique_ptr<ParsedExpression>> children,
+	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
+	                   bool distinct = false, bool is_operator = false);
+	FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
+	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
+	                   bool distinct = false, bool is_operator = false);
 
-	//! The actual subquery
-	unique_ptr<SelectStatement> subquery;
-	//! The subquery type
-	SubqueryType subquery_type;
-	//! the child expression to compare with (in case of IN, ANY, ALL operators, empty for EXISTS queries and scalar
-	//! subquery)
-	unique_ptr<ParsedExpression> child;
-	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators), empty otherwise
-	ExpressionType comparison_type;
+	//! Schema of the function
+	string schema;
+	//! Function name
+	string function_name;
+	//! Whether or not the function is an operator, only used for rendering
+	bool is_operator;
+	//! List of arguments to the function
+	vector<unique_ptr<ParsedExpression>> children;
+	//! Whether or not the aggregate function is distinct, only used for aggregates
+	bool distinct;
+	//! Expression representing a filter, only used for aggregates
+	unique_ptr<ParsedExpression> filter;
+	//! Modifier representing an ORDER BY, only used for aggregates
+	unique_ptr<OrderModifier> order_bys;
 
 public:
-	bool HasSubquery() const override {
-		return true;
-	}
-	bool IsScalar() const override {
-		return false;
-	}
-
 	string ToString() const override;
 
-	static bool Equals(const SubqueryExpression *a, const SubqueryExpression *b);
-
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
+	hash_t Hash() const override;
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/constant_expression.hpp
+// duckdb/parser/expression/default_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21101,34 +21204,29 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! ConstantExpression represents a constant value in the query
-class ConstantExpression : public ParsedExpression {
+//! Represents the default value of a column
+class DefaultExpression : public ParsedExpression {
 public:
-	explicit ConstantExpression(Value val);
-
-	//! The constant value referenced
-	Value value;
+	DefaultExpression();
 
 public:
-	string ToString() const override;
+	bool IsScalar() const override {
+		return false;
+	}
 
-	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
-	hash_t Hash() const override;
+	string ToString() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
-
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/lambda_expression.hpp
+// duckdb/parser/expression/comparison_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21137,35 +21235,31 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! LambdaExpression represents a lambda operator that can be used for e.g. mapping an expression to a list
-//! Lambda expressions are written in the form of "capture -> expr", e.g. "x -> x + 1"
-class LambdaExpression : public ParsedExpression {
+//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
+//! and has two children.
+class ComparisonExpression : public ParsedExpression {
 public:
-	LambdaExpression(vector<string> parameters, unique_ptr<ParsedExpression> expression);
+	ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
 
-	vector<string> parameters;
-	unique_ptr<ParsedExpression> expression;
+	unique_ptr<ParsedExpression> left;
+	unique_ptr<ParsedExpression> right;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
-	hash_t Hash() const override;
+	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
-
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/positional_reference_expression.hpp
+// duckdb/parser/expression/constant_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21174,32 +21268,34 @@ public:
 
 
 
+
 namespace duckdb {
-class PositionalReferenceExpression : public ParsedExpression {
+
+//! ConstantExpression represents a constant value in the query
+class ConstantExpression : public ParsedExpression {
 public:
-	PositionalReferenceExpression(idx_t index);
+	explicit ConstantExpression(Value val);
 
-	idx_t index;
+	//! The constant value referenced
+	Value value;
 
 public:
-	bool IsScalar() const override {
-		return false;
-	}
-
 	string ToString() const override;
 
-	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
-	unique_ptr<ParsedExpression> Copy() const override;
+	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
 	hash_t Hash() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/case_expression.hpp
+// duckdb/parser/expression/operator_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21210,29 +21306,24 @@ public:
 
 
 namespace duckdb {
-
-struct CaseCheck {
-	unique_ptr<ParsedExpression> when_expr;
-	unique_ptr<ParsedExpression> then_expr;
-};
-
-//! The CaseExpression represents a CASE expression in the query
-class CaseExpression : public ParsedExpression {
+//! Represents a built-in operator expression
+class OperatorExpression : public ParsedExpression {
 public:
-	CaseExpression();
+	explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
+	                            unique_ptr<ParsedExpression> right = nullptr);
+	OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
 
-	vector<CaseCheck> case_checks;
-	unique_ptr<ParsedExpression> else_expr;
+	vector<unique_ptr<ParsedExpression>> children;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const CaseExpression *a, const CaseExpression *b);
+	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -21265,14 +21356,14 @@ public:
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/comparison_expression.hpp
+// duckdb/parser/expression/positional_reference_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21282,26 +21373,30 @@ public:
 
 
 namespace duckdb {
-//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
-//! and has two children.
-class ComparisonExpression : public ParsedExpression {
+class PositionalReferenceExpression : public ParsedExpression {
 public:
-	ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
+	PositionalReferenceExpression(idx_t index);
 
-	unique_ptr<ParsedExpression> left;
-	unique_ptr<ParsedExpression> right;
+	idx_t index;
 
 public:
-	string ToString() const override;
+	bool IsScalar() const override {
+		return false;
+	}
 
-	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
+	string ToString() const override;
 
+	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
 	unique_ptr<ParsedExpression> Copy() const override;
+	hash_t Hash() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -21336,23 +21431,15 @@ public:
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 
-
-
-
-
-
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/default_expression.hpp
+// duckdb/parser/expression/collate_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21362,28 +21449,41 @@ public:
 
 
 namespace duckdb {
-//! Represents the default value of a column
-class DefaultExpression : public ParsedExpression {
-public:
-	DefaultExpression();
 
+//! CollateExpression represents a COLLATE statement
+class CollateExpression : public ParsedExpression {
 public:
-	bool IsScalar() const override {
-		return false;
-	}
+	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
+
+	//! The child of the cast expression
+	unique_ptr<ParsedExpression> child;
+	//! The collation clause
+	string collation;
 
+public:
 	string ToString() const override;
 
+	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 
+
+
+
+
+
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/function_expression.hpp
+// duckdb/parser/expression/parameter_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21392,46 +21492,28 @@ public:
 
 
 
-
-
 namespace duckdb {
-//! Represents a function call
-class FunctionExpression : public ParsedExpression {
+class ParameterExpression : public ParsedExpression {
 public:
-	FunctionExpression(string schema_name, const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
-	                   bool distinct = false, bool is_operator = false);
-	FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
-	                   bool distinct = false, bool is_operator = false);
+	ParameterExpression();
 
-	//! Schema of the function
-	string schema;
-	//! Function name
-	string function_name;
-	//! Whether or not the function is an operator, only used for rendering
-	bool is_operator;
-	//! List of arguments to the function
-	vector<unique_ptr<ParsedExpression>> children;
-	//! Whether or not the aggregate function is distinct, only used for aggregates
-	bool distinct;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<ParsedExpression> filter;
-	//! Modifier representing an ORDER BY, only used for aggregates
-	unique_ptr<OrderModifier> order_bys;
+	idx_t parameter_nr;
 
 public:
+	bool IsScalar() const override {
+		return true;
+	}
+	bool HasParameter() const override {
+		return true;
+	}
+
 	string ToString() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;
-
-	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
 	hash_t Hash() const override;
 
-	//! Serializes a FunctionExpression to a stand-alone binary blob
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into an FunctionExpression
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 
@@ -21439,7 +21521,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/operator_expression.hpp
+// duckdb/parser/expression/star_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21450,31 +21532,35 @@ public:
 
 
 namespace duckdb {
-//! Represents a built-in operator expression
-class OperatorExpression : public ParsedExpression {
+
+//! Represents a * expression in the SELECT clause
+class StarExpression : public ParsedExpression {
 public:
-	explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
-	                            unique_ptr<ParsedExpression> right = nullptr);
-	OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	StarExpression(string relation_name = string());
 
-	vector<unique_ptr<ParsedExpression>> children;
+	//! The relation name in case of tbl.*, or empty if this is a normal *
+	string relation_name;
+	//! List of columns to exclude from the STAR expression
+	case_insensitive_set_t exclude_list;
+	//! List of columns to replace with another expression
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
+	static bool Equals(const StarExpression *a, const StarExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/parameter_expression.hpp
+// duckdb/parser/expression/subquery_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21483,39 +21569,49 @@ public:
 
 
 
+
+
 namespace duckdb {
-class ParameterExpression : public ParsedExpression {
+
+//! Represents a subquery
+class SubqueryExpression : public ParsedExpression {
 public:
-	ParameterExpression();
+	SubqueryExpression();
 
-	idx_t parameter_nr;
+	//! The actual subquery
+	unique_ptr<SelectStatement> subquery;
+	//! The subquery type
+	SubqueryType subquery_type;
+	//! the child expression to compare with (in case of IN, ANY, ALL operators, empty for EXISTS queries and scalar
+	//! subquery)
+	unique_ptr<ParsedExpression> child;
+	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators), empty otherwise
+	ExpressionType comparison_type;
 
 public:
-	bool IsScalar() const override {
+	bool HasSubquery() const override {
 		return true;
 	}
-	bool HasParameter() const override {
-		return true;
+	bool IsScalar() const override {
+		return false;
 	}
 
 	string ToString() const override;
 
+	static bool Equals(const SubqueryExpression *a, const SubqueryExpression *b);
+
 	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
 
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 
 
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_type_info.hpp
+// duckdb/parser/parsed_data/create_collation_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21525,26 +21621,30 @@ public:
 
 
 
-
-
 namespace duckdb {
 
-struct CreateTypeInfo : public CreateInfo {
-
-	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+struct CreateCollationInfo : public CreateInfo {
+	CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p, bool not_required_for_equality_p)
+	    : CreateInfo(CatalogType::COLLATION_ENTRY), function(move(function_p)), combinable(combinable_p),
+	      not_required_for_equality(not_required_for_equality_p) {
+		this->name = move(name_p);
 	}
 
-	//! Name of the Type
+	//! The name of the collation
 	string name;
-	//! Shared Pointer of Logical Type
-	unique_ptr<LogicalType> type;
+	//! The collation function to push in case collation is required
+	ScalarFunction function;
+	//! Whether or not the collation can be combined with other collations.
+	bool combinable;
+	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
+	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
+	//! speeds up processing.
+	bool not_required_for_equality;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateTypeInfo>();
+		auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
 		CopyProperties(*result);
-		result->name = name;
-		result->type = make_unique<LogicalType>(*type);
 		return move(result);
 	}
 };
@@ -21583,7 +21683,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/export_table_data.hpp
+// duckdb/parser/parsed_data/show_select_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21595,26 +21695,31 @@ public:
 
 namespace duckdb {
 
-struct ExportedTableData {
-	//! Name of the exported table
-	string table_name;
-
-	//! Name of the schema
-	string schema_name;
-
-	//! Path to be exported
-	string file_path;
-};
+struct ShowSelectInfo : public ParseInfo {
+	//! Types of projected columns
+	vector<LogicalType> types;
+	//! The QueryNode of select query
+	unique_ptr<QueryNode> query;
+	//! Aliases of projected columns
+	vector<string> aliases;
+	//! Whether or not we are requesting a summary or a describe
+	bool is_summary;
 
-struct BoundExportData : public ParseInfo {
-	unordered_map<TableCatalogEntry *, ExportedTableData> data;
+	unique_ptr<ShowSelectInfo> Copy() {
+		auto result = make_unique<ShowSelectInfo>();
+		result->types = types;
+		result->query = query->Copy();
+		result->aliases = aliases;
+		result->is_summary = is_summary;
+		return result;
+	}
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/vacuum_info.hpp
+// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21623,17 +21728,39 @@ struct BoundExportData : public ParseInfo {
 
 
 
+
 namespace duckdb {
 
-struct VacuumInfo : public ParseInfo {
-	// nothing for now
+struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
+	explicit CreateAggregateFunctionInfo(AggregateFunction function)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
+		this->name = function.name;
+		functions.AddFunction(move(function));
+	}
+
+	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
+		this->name = functions.name;
+		for (auto &func : functions.functions) {
+			func.name = functions.name;
+		}
+	}
+
+	AggregateFunctionSet functions;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
+		CopyProperties(*result);
+		return move(result);
+	}
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_collation_info.hpp
+// duckdb/parser/parsed_data/create_type_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21643,34 +21770,49 @@ struct VacuumInfo : public ParseInfo {
 
 
 
+
+
 namespace duckdb {
 
-struct CreateCollationInfo : public CreateInfo {
-	CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p, bool not_required_for_equality_p)
-	    : CreateInfo(CatalogType::COLLATION_ENTRY), function(move(function_p)), combinable(combinable_p),
-	      not_required_for_equality(not_required_for_equality_p) {
-		this->name = move(name_p);
+struct CreateTypeInfo : public CreateInfo {
+
+	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
 	}
 
-	//! The name of the collation
+	//! Name of the Type
 	string name;
-	//! The collation function to push in case collation is required
-	ScalarFunction function;
-	//! Whether or not the collation can be combined with other collations.
-	bool combinable;
-	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
-	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
-	//! speeds up processing.
-	bool not_required_for_equality;
+	//! Logical Type
+	LogicalType type;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
+		auto result = make_unique<CreateTypeInfo>();
 		CopyProperties(*result);
+		result->name = name;
+		result->type = type;
 		return move(result);
 	}
 };
 
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/vacuum_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct VacuumInfo : public ParseInfo {
+	// nothing for now
+};
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -21719,7 +21861,43 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_view_info.hpp
+// duckdb/parser/parsed_data/transaction_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
+
+struct TransactionInfo : public ParseInfo {
+	explicit TransactionInfo(TransactionType type) : type(type) {
+	}
+
+	//! The type of transaction statement
+	TransactionType type;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_macro_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/macro_function.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21729,31 +21907,75 @@ public:
 
 
 
+
+
 namespace duckdb {
 
-struct CreateViewInfo : public CreateInfo {
-	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
+class MacroCatalogEntry;
+
+class MacroFunction {
+public:
+	explicit MacroFunction(unique_ptr<ParsedExpression> expression);
+
+	//! Check whether the supplied arguments are valid
+	static string ValidateArguments(MacroCatalogEntry &macro_func, FunctionExpression &function_expr,
+	                                vector<unique_ptr<ParsedExpression>> &positionals,
+	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
+	//! The macro expression
+	unique_ptr<ParsedExpression> expression;
+	//! The positional parameters
+	vector<unique_ptr<ParsedExpression>> parameters;
+	//! The default parameters and their associated values
+	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
+
+public:
+	unique_ptr<MacroFunction> Copy();
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+struct CreateMacroInfo : public CreateFunctionInfo {
+	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
 	}
-	CreateViewInfo(string schema, string view_name)
-	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
+
+	unique_ptr<MacroFunction> function;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateMacroInfo>();
+		result->function = function->Copy();
+		result->name = name;
+		CopyProperties(*result);
+		return move(result);
 	}
+};
 
-	//! Table name to insert to
-	string view_name;
-	//! Aliases of the view
-	vector<string> aliases;
-	//! Return types
-	vector<LogicalType> types;
-	//! The SelectStatement of the view
-	unique_ptr<SelectStatement> query;
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_schema_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct CreateSchemaInfo : public CreateInfo {
+	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
+	}
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateViewInfo>(schema, view_name);
+		auto result = make_unique<CreateSchemaInfo>();
 		CopyProperties(*result);
-		result->aliases = aliases;
-		result->types = types;
-		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
 		return move(result);
 	}
 };
@@ -21806,9 +22028,9 @@ public:
 	unique_ptr<TableRef> Copy() override;
 
 	//! Serializes a blob into a BaseTableRef
-	void Serialize(Serializer &serializer) override;
+	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 
@@ -21850,95 +22072,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/show_select_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct ShowSelectInfo : public ParseInfo {
-	//! Types of projected columns
-	vector<LogicalType> types;
-	//! The QueryNode of select query
-	unique_ptr<QueryNode> query;
-	//! Aliases of projected columns
-	vector<string> aliases;
-	//! Whether or not we are requesting a summary or a describe
-	bool is_summary;
-
-	unique_ptr<ShowSelectInfo> Copy() {
-		auto result = make_unique<ShowSelectInfo>();
-		result->types = types;
-		result->query = query->Copy();
-		result->aliases = aliases;
-		result->is_summary = is_summary;
-		return result;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/transaction_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
-
-struct TransactionInfo : public ParseInfo {
-	explicit TransactionInfo(TransactionType type) : type(type) {
-	}
-
-	//! The type of transaction statement
-	TransactionType type;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_schema_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct CreateSchemaInfo : public CreateInfo {
-	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
-	}
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateSchemaInfo>();
-		CopyProperties(*result);
-		return move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_pragma_function_info.hpp
+// duckdb/parser/parsed_data/create_pragma_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21978,7 +22112,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
+// duckdb/parser/parsed_data/export_table_data.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21990,47 +22124,26 @@ public:
 
 namespace duckdb {
 
-struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
-	explicit CreateAggregateFunctionInfo(AggregateFunction function)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
-		this->name = function.name;
-		functions.AddFunction(move(function));
-	}
+struct ExportedTableData {
+	//! Name of the exported table
+	string table_name;
 
-	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
-		this->name = functions.name;
-		for (auto &func : functions.functions) {
-			func.name = functions.name;
-		}
-	}
+	//! Name of the schema
+	string schema_name;
 
-	AggregateFunctionSet functions;
+	//! Path to be exported
+	string file_path;
+};
 
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
-		CopyProperties(*result);
-		return move(result);
-	}
+struct BoundExportData : public ParseInfo {
+	unordered_map<TableCatalogEntry *, ExportedTableData> data;
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_macro_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/macro_function.hpp
+// duckdb/parser/parsed_data/create_view_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22040,48 +22153,31 @@ public:
 
 
 
-
-
-namespace duckdb {
-
-class MacroCatalogEntry;
-
-class MacroFunction {
-public:
-	explicit MacroFunction(unique_ptr<ParsedExpression> expression);
-
-	//! Check whether the supplied arguments are valid
-	static string ValidateArguments(MacroCatalogEntry &macro_func, FunctionExpression &function_expr,
-	                                vector<unique_ptr<ParsedExpression>> &positionals,
-	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
-	//! The macro expression
-	unique_ptr<ParsedExpression> expression;
-	//! The positional parameters
-	vector<unique_ptr<ParsedExpression>> parameters;
-	//! The default parameters and their associated values
-	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
-
-public:
-	unique_ptr<MacroFunction> Copy();
-};
-
-} // namespace duckdb
-
-
 namespace duckdb {
 
-struct CreateMacroInfo : public CreateFunctionInfo {
-	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
+struct CreateViewInfo : public CreateInfo {
+	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
+	}
+	CreateViewInfo(string schema, string view_name)
+	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
 	}
 
-	unique_ptr<MacroFunction> function;
+	//! Table name to insert to
+	string view_name;
+	//! Aliases of the view
+	vector<string> aliases;
+	//! Return types
+	vector<LogicalType> types;
+	//! The SelectStatement of the view
+	unique_ptr<SelectStatement> query;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateMacroInfo>();
-		result->function = function->Copy();
-		result->name = name;
+		auto result = make_unique<CreateViewInfo>(schema, view_name);
 		CopyProperties(*result);
+		result->aliases = aliases;
+		result->types = types;
+		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
 		return move(result);
 	}
 };
@@ -22090,7 +22186,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/subqueryref.hpp
+// duckdb/parser/tableref/table_function_ref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22100,26 +22196,32 @@ public:
 
 
 
+
+
 namespace duckdb {
-//! Represents a subquery
-class SubqueryRef : public TableRef {
+//! Represents a Table producing function
+class TableFunctionRef : public TableRef {
 public:
-	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
+	TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTION) {
+	}
 
-	//! The subquery
-	unique_ptr<SelectStatement> subquery;
-	//! Aliases for the column names
+	unique_ptr<ParsedExpression> function;
 	vector<string> column_name_alias;
 
+	// if the function takes a subquery as argument its in here
+	unique_ptr<SelectStatement> subquery;
+
 public:
+	string ToString() const override;
+
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a SubqueryRef
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a SubqueryRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+	//! Serializes a blob into a BaseTableRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a BaseTableRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -22152,15 +22254,15 @@ public:
 	unique_ptr<TableRef> Copy() override;
 
 	//! Serializes a blob into a CrossProductRef
-	void Serialize(Serializer &serializer) override;
+	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a CrossProductRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/joinref.hpp
+// duckdb/parser/tableref/emptytableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22169,41 +22271,27 @@ public:
 
 
 
-
-
-
-
 namespace duckdb {
-//! Represents a JOIN between two expressions
-class JoinRef : public TableRef {
+//! Represents a cross product
+class EmptyTableRef : public TableRef {
 public:
-	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
+	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
 	}
 
-	//! The left hand side of the join
-	unique_ptr<TableRef> left;
-	//! The right hand side of the join
-	unique_ptr<TableRef> right;
-	//! The join condition
-	unique_ptr<ParsedExpression> condition;
-	//! The join type
-	JoinType type;
-	//! Natural join
-	bool is_natural;
-	//! The set of USING columns (if any)
-	vector<string> using_columns;
-
 public:
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a JoinRef
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a JoinRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+	//! Serializes a blob into a DummyTableRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a DummyTableRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -22239,15 +22327,16 @@ public:
 	unique_ptr<TableRef> Copy() override;
 
 	//! Serializes a blob into a ExpressionListRef
-	void Serialize(Serializer &serializer) override;
+	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a ExpressionListRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/emptytableref.hpp
+// duckdb/parser/tableref/joinref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22256,28 +22345,46 @@ public:
 
 
 
+
+
+
+
 namespace duckdb {
-//! Represents a cross product
-class EmptyTableRef : public TableRef {
+//! Represents a JOIN between two expressions
+class JoinRef : public TableRef {
 public:
-	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
+	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
 	}
 
+	//! The left hand side of the join
+	unique_ptr<TableRef> left;
+	//! The right hand side of the join
+	unique_ptr<TableRef> right;
+	//! The join condition
+	unique_ptr<ParsedExpression> condition;
+	//! The join type
+	JoinType type;
+	//! Natural join
+	bool is_natural;
+	//! The set of USING columns (if any)
+	vector<string> using_columns;
+
 public:
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a DummyTableRef
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a DummyTableRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+	//! Serializes a blob into a JoinRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a JoinRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/table_function_ref.hpp
+// duckdb/parser/tableref/subqueryref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22287,38 +22394,27 @@ public:
 
 
 
-
-
 namespace duckdb {
-//! Represents a Table producing function
-class TableFunctionRef : public TableRef {
+//! Represents a subquery
+class SubqueryRef : public TableRef {
 public:
-	TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTION) {
-	}
-
-	unique_ptr<ParsedExpression> function;
-	vector<string> column_name_alias;
+	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
 
-	// if the function takes a subquery as argument its in here
+	//! The subquery
 	unique_ptr<SelectStatement> subquery;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
 
 public:
-	string ToString() const override;
-
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a BaseTableRef
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a BaseTableRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+	//! Serializes a blob into a SubqueryRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a SubqueryRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 
 
-
-
-
-
-