duckdb 0.5.2-dev18.0 → 0.5.2-dev194.0

package/src/duckdb.hpp

@@ -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 "09248843b"
-#define DUCKDB_VERSION "v0.5.2-dev18"
+#define DUCKDB_SOURCE_ID "a0fc1e9cd"
+#define DUCKDB_VERSION "v0.5.2-dev194"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1170,7 +1170,7 @@ struct UserType{
 
 struct EnumType{
 	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
-	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string& key);
+	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t& key);
 	DUCKDB_API static Vector &GetValuesInsertOrder(const LogicalType &type);
 	DUCKDB_API static idx_t GetSize(const LogicalType &type);
 	DUCKDB_API static const string GetValue(const Value &val);
@@ -2871,6 +2871,7 @@ public:
 
 namespace duckdb {
 
+class CastFunctionSet;
 class Deserializer;
 class Serializer;
 
@@ -3052,12 +3053,20 @@ public:
 	DUCKDB_API uintptr_t GetPointer() const;
 
 	//! Cast this value to another type, throws exception if its not possible
-	DUCKDB_API Value CastAs(const LogicalType &target_type, bool strict = false) const;
+	DUCKDB_API Value CastAs(CastFunctionSet &set, const LogicalType &target_type, bool strict = false) const;
+	DUCKDB_API Value CastAs(ClientContext &context, const LogicalType &target_type, bool strict = false) const;
+	DUCKDB_API Value DefaultCastAs(const LogicalType &target_type, bool strict = false) const;
 	//! Tries to cast this value to another type, and stores the result in "new_value"
-	DUCKDB_API bool TryCastAs(const LogicalType &target_type, Value &new_value, string *error_message,
-	                          bool strict = false) const;
+	DUCKDB_API bool TryCastAs(CastFunctionSet &set, const LogicalType &target_type, Value &new_value,
+	                          string *error_message, bool strict = false) const;
+	DUCKDB_API bool TryCastAs(ClientContext &context, const LogicalType &target_type, Value &new_value,
+	                          string *error_message, bool strict = false) const;
+	DUCKDB_API bool DefaultTryCastAs(const LogicalType &target_type, Value &new_value, string *error_message,
+	                                 bool strict = false) const;
 	//! Tries to cast this value to another type, and stores the result in THIS value again
-	DUCKDB_API bool TryCastAs(const LogicalType &target_type, bool strict = false);
+	DUCKDB_API bool TryCastAs(CastFunctionSet &set, const LogicalType &target_type, bool strict = false);
+	DUCKDB_API bool TryCastAs(ClientContext &context, const LogicalType &target_type, bool strict = false);
+	DUCKDB_API bool DefaultTryCastAs(const LogicalType &target_type, bool strict = false);
 
 	//! Serializes a Value to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
@@ -3098,7 +3107,9 @@ public:
 
 	//! Returns true if the values are (approximately) equivalent. Note this is NOT the SQL equivalence. For this
 	//! function, NULL values are equivalent and floating point values that are close are equivalent.
-	DUCKDB_API static bool ValuesAreEqual(const Value &result_value, const Value &value);
+	DUCKDB_API static bool ValuesAreEqual(CastFunctionSet &set, const Value &result_value, const Value &value);
+	DUCKDB_API static bool ValuesAreEqual(ClientContext &context, const Value &result_value, const Value &value);
+	DUCKDB_API static bool DefaultValuesAreEqual(const Value &result_value, const Value &value);
 	//! Returns true if the values are not distinct from each other, following SQL semantics for NOT DISTINCT FROM.
 	DUCKDB_API static bool NotDistinctFrom(const Value &lvalue, const Value &rvalue);
 
@@ -4818,6 +4829,7 @@ private:
 #include <functional>
 
 namespace duckdb {
+class CastFunctionSet;
 
 // VectorOperations contains a set of operations that operate on sets of
 // vectors. In general, the operators must all have the same type, otherwise an
@@ -4959,10 +4971,16 @@ struct VectorOperations {
 	//! Cast the data from the source type to the target type. Any elements that could not be converted are turned into
 	//! NULLs. If any elements cannot be converted, returns false and fills in the error_message. If no error message is
 	//! provided, an exception is thrown instead.
-	DUCKDB_API static bool TryCast(Vector &source, Vector &result, idx_t count, string *error_message,
-	                               bool strict = false);
+	DUCKDB_API static bool TryCast(CastFunctionSet &set, Vector &source, Vector &result, idx_t count,
+	                               string *error_message, bool strict = false);
+	DUCKDB_API static bool DefaultTryCast(Vector &source, Vector &result, idx_t count, string *error_message,
+	                                      bool strict = false);
+	DUCKDB_API static bool TryCast(ClientContext &context, Vector &source, Vector &result, idx_t count,
+	                               string *error_message, bool strict = false);
 	//! Cast the data from the source type to the target type. Throws an exception if the cast fails.
-	DUCKDB_API static void Cast(Vector &source, Vector &result, idx_t count, bool strict = false);
+	DUCKDB_API static void Cast(ClientContext &context, Vector &source, Vector &result, idx_t count,
+	                            bool strict = false);
+	DUCKDB_API static void DefaultCast(Vector &source, Vector &result, idx_t count, bool strict = false);
 
 	// Copy the data of <source> to the target vector
 	static void Copy(const Vector &source, Vector &target, idx_t source_count, idx_t source_offset,
@@ -6987,28 +7005,6 @@ public:
 	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
 	                                      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
-	DUCKDB_API static idx_t BindFunction(const string &name, ScalarFunctionSet &functions,
-	                                     const vector<LogicalType> &arguments, string &error);
-	DUCKDB_API static idx_t BindFunction(const string &name, ScalarFunctionSet &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, string &error);
-	//! Bind an aggregate 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
-	DUCKDB_API static idx_t BindFunction(const string &name, AggregateFunctionSet &functions,
-	                                     const vector<LogicalType> &arguments, string &error);
-	DUCKDB_API static idx_t BindFunction(const string &name, AggregateFunctionSet &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, string &error);
-	//! Bind a table 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
-	DUCKDB_API static idx_t BindFunction(const string &name, TableFunctionSet &functions,
-	                                     const vector<LogicalType> &arguments, string &error);
-	DUCKDB_API static idx_t BindFunction(const string &name, TableFunctionSet &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, string &error);
-	//! Bind a pragma function from the set of functions and input arguments
-	DUCKDB_API static idx_t BindFunction(const string &name, PragmaFunctionSet &functions, PragmaInfo &info,
-	                                     string &error);
-
 	//! Used in the bind to erase an argument from a function
 	DUCKDB_API static void EraseArgument(SimpleFunction &bound_function, vector<unique_ptr<Expression>> &arguments,
 	                                     idx_t argument_index);
@@ -7068,9 +7064,6 @@ public:
 public:
 	DUCKDB_API hash_t Hash() const;
 
-	//! Cast a set of expressions to the arguments of this function
-	DUCKDB_API void CastToFunctionArguments(vector<unique_ptr<Expression>> &children);
-
 	DUCKDB_API string ToString() override;
 };
 
@@ -8032,20 +8025,6 @@ public:
 	function_serialize_t serialize;
 	function_deserialize_t deserialize;
 
-	DUCKDB_API static unique_ptr<Expression> BindScalarFunction(ClientContext &context, const string &schema,
-	                                                            const string &name,
-	                                                            vector<unique_ptr<Expression>> children, string &error,
-	                                                            bool is_operator = false, Binder *binder = nullptr);
-	DUCKDB_API static unique_ptr<Expression> BindScalarFunction(ClientContext &context,
-	                                                            ScalarFunctionCatalogEntry &function,
-	                                                            vector<unique_ptr<Expression>> children, string &error,
-	                                                            bool is_operator = false, Binder *binder = nullptr);
-
-	DUCKDB_API static unique_ptr<BoundFunctionExpression> BindScalarFunction(ClientContext &context,
-	                                                                         ScalarFunction bound_function,
-	                                                                         vector<unique_ptr<Expression>> children,
-	                                                                         bool is_operator = false);
-
 	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
 	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;
 
@@ -9491,7 +9470,7 @@ struct ForeignKeyInfo {
 	//! The set of main key table's column's index
 	vector<storage_t> pk_keys;
 	//! The set of foreign key table's column's index
-	vector<idx_t> fk_keys;
+	vector<storage_t> fk_keys;
 };
 
 //! Constraint is the base class of any type of table constraint.
@@ -10705,16 +10684,6 @@ public:
 		return !(*this == rhs);
 	}
 
-	DUCKDB_API static unique_ptr<BoundAggregateExpression>
-	BindAggregateFunction(ClientContext &context, AggregateFunction bound_function,
-	                      vector<unique_ptr<Expression>> children, unique_ptr<Expression> filter = nullptr,
-	                      bool is_distinct = false, unique_ptr<BoundOrderModifier> order_bys = nullptr);
-
-	DUCKDB_API static unique_ptr<FunctionData> BindSortedAggregate(AggregateFunction &bound_function,
-	                                                               vector<unique_ptr<Expression>> &children,
-	                                                               unique_ptr<FunctionData> bind_info,
-	                                                               unique_ptr<BoundOrderModifier> order_bys);
-
 public:
 	template <class STATE, class RESULT_TYPE, class OP>
 	static AggregateFunction NullaryAggregate(LogicalType return_type) {
@@ -13806,6 +13775,7 @@ struct ParseInfo {
 
 
 namespace duckdb {
+struct AlterInfo;
 
 enum class OnCreateConflict : uint8_t {
 	// Standard: throw error
@@ -13813,7 +13783,9 @@ enum class OnCreateConflict : uint8_t {
 	// CREATE IF NOT EXISTS, silently do nothing on conflict
 	IGNORE_ON_CONFLICT,
 	// CREATE OR REPLACE
-	REPLACE_ON_CONFLICT
+	REPLACE_ON_CONFLICT,
+	// Update on conflict - only support for functions. Add a function overload if the function already exists.
+	ALTER_ON_CONFLICT
 };
 
 struct CreateInfo : public ParseInfo {
@@ -13850,6 +13822,8 @@ public:
 	virtual unique_ptr<CreateInfo> Copy() const = 0;
 
 	DUCKDB_API void CopyProperties(CreateInfo &other) const;
+	//! Generates an alter statement from the create statement - used for OnCreateConflict::ALTER_ON_CONFLICT
+	DUCKDB_API virtual unique_ptr<AlterInfo> GetAlterInfo() const;
 };
 
 } // namespace duckdb
@@ -13927,6 +13901,15 @@ protected:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/alter_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
 
 
 
@@ -13939,14 +13922,13 @@ enum class AlterType : uint8_t {
 	ALTER_TABLE = 1,
 	ALTER_VIEW = 2,
 	ALTER_SEQUENCE = 3,
-	CHANGE_OWNERSHIP = 4
+	CHANGE_OWNERSHIP = 4,
+	ALTER_FUNCTION = 5
 };
 
-enum AlterForeignKeyType : uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };
-
 struct AlterInfo : public ParseInfo {
 	AlterInfo(AlterType type, string schema, string name, bool if_exists);
-	~AlterInfo() override;
+	virtual ~AlterInfo() override;
 
 	AlterType type;
 	//! if exists
@@ -13964,6 +13946,16 @@ public:
 	static unique_ptr<AlterInfo> Deserialize(Deserializer &source);
 };
 
+} // namespace duckdb
+
+
+
+
+
+namespace duckdb {
+
+enum AlterForeignKeyType : uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };
+
 //===--------------------------------------------------------------------===//
 // Change Ownership
 //===--------------------------------------------------------------------===//
@@ -14749,17 +14741,124 @@ public:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/cast/default_casts.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+class CastFunctionSet;
+
+//! Extra data that can be attached to a bind function of a cast, and is available during binding
+struct BindCastInfo {
+	DUCKDB_API virtual ~BindCastInfo();
+};
+
+//! Extra data that can be returned by the bind of a cast, and is available during execution of a cast
+struct BoundCastData {
+	DUCKDB_API virtual ~BoundCastData();
+
+	DUCKDB_API virtual unique_ptr<BoundCastData> Copy() const = 0;
+};
+
+struct CastParameters {
+	CastParameters() {
+	}
+	CastParameters(BoundCastData *cast_data, bool strict, string *error_message)
+	    : cast_data(cast_data), strict(strict), error_message(error_message) {
+	}
+	CastParameters(CastParameters &parent, BoundCastData *cast_data = nullptr)
+	    : cast_data(cast_data), strict(parent.strict), error_message(parent.error_message) {
+	}
+
+	//! The bound cast data (if any)
+	BoundCastData *cast_data = nullptr;
+	//! whether or not to enable strict casting
+	bool strict = false;
+	// out: error message in case cast has failed
+	string *error_message = nullptr;
+};
+
+typedef bool (*cast_function_t)(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+
+struct BoundCastInfo {
+	BoundCastInfo(cast_function_t function,
+	              unique_ptr<BoundCastData> cast_data = nullptr); // NOLINT: allow explicit cast from cast_function_t
+
+	cast_function_t function;
+	unique_ptr<BoundCastData> cast_data;
+
+public:
+	BoundCastInfo Copy() const;
+};
+
+struct BindCastInput {
+	BindCastInput(CastFunctionSet &function_set, BindCastInfo *info) : function_set(function_set), info(info) {
+	}
+
+	CastFunctionSet &function_set;
+	BindCastInfo *info;
+};
+
+struct DefaultCasts {
+	static BoundCastInfo GetDefaultCastFunction(BindCastInput &input, const LogicalType &source,
+	                                            const LogicalType &target);
+
+	static bool NopCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+	static bool TryVectorNullCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+	static bool ReinterpretCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+
+private:
+	static BoundCastInfo BlobCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo DateCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo DecimalCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo EnumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo IntervalCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo NumericCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo MapCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo PointerCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo StringCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo StructCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo TimeCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo TimeTzCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo TimestampCastSwitch(BindCastInput &input, const LogicalType &source,
+	                                         const LogicalType &target);
+	static BoundCastInfo TimestampTzCastSwitch(BindCastInput &input, const LogicalType &source,
+	                                           const LogicalType &target);
+	static BoundCastInfo TimestampNsCastSwitch(BindCastInput &input, const LogicalType &source,
+	                                           const LogicalType &target);
+	static BoundCastInfo TimestampMsCastSwitch(BindCastInput &input, const LogicalType &source,
+	                                           const LogicalType &target);
+	static BoundCastInfo TimestampSecCastSwitch(BindCastInput &input, const LogicalType &source,
+	                                            const LogicalType &target);
+	static BoundCastInfo UUIDCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+};
+
+} // namespace duckdb
+
 
 namespace duckdb {
 
 class BoundCastExpression : public Expression {
 public:
-	BoundCastExpression(unique_ptr<Expression> child, LogicalType target_type, bool try_cast = false);
+	BoundCastExpression(unique_ptr<Expression> child, LogicalType target_type, BoundCastInfo bound_cast,
+	                    bool try_cast = false);
 
 	//! The child type
 	unique_ptr<Expression> child;
 	//! Whether to use try_cast or not. try_cast converts cast failures into NULLs instead of throwing an error.
 	bool try_cast;
+	//! The bound cast info
+	BoundCastInfo bound_cast;
 
 public:
 	LogicalType source_type() {
@@ -14767,9 +14866,12 @@ public:
 		return child->return_type;
 	}
 
+	//! Cast an expression to the specified SQL type, using only the built-in SQL casts
+	static unique_ptr<Expression> AddDefaultCastToType(unique_ptr<Expression> expr, const LogicalType &target_type,
+	                                                   bool try_cast = false);
 	//! Cast an expression to the specified SQL type if required
-	static unique_ptr<Expression> AddCastToType(unique_ptr<Expression> expr, const LogicalType &target_type,
-	                                            bool try_cast = false);
+	static unique_ptr<Expression> AddCastToType(ClientContext &context, unique_ptr<Expression> expr,
+	                                            const LogicalType &target_type, bool try_cast = false);
 	//! Returns true if a cast is invertible (i.e. CAST(s -> t -> s) = s for all values of s). This is not true for e.g.
 	//! boolean casts, because that can be e.g. -1 -> TRUE -> 1. This is necessary to prevent some optimizer bugs.
 	static bool CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type);
@@ -15622,21 +15724,21 @@ class ScalarFunctionSet : public FunctionSet<ScalarFunction> {
 public:
 	DUCKDB_API explicit ScalarFunctionSet(string name);
 
-	DUCKDB_API ScalarFunction GetFunctionByArguments(const vector<LogicalType> &arguments);
+	DUCKDB_API ScalarFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
 };
 
 class AggregateFunctionSet : public FunctionSet<AggregateFunction> {
 public:
 	DUCKDB_API explicit AggregateFunctionSet(string name);
 
-	DUCKDB_API AggregateFunction GetFunctionByArguments(const vector<LogicalType> &arguments);
+	DUCKDB_API AggregateFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
 };
 
 class TableFunctionSet : public FunctionSet<TableFunction> {
 public:
 	DUCKDB_API explicit TableFunctionSet(string name);
 
-	TableFunction GetFunctionByArguments(const vector<LogicalType> &arguments);
+	TableFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
 };
 
 class PragmaFunctionSet : public FunctionSet<PragmaFunction> {
@@ -16080,11 +16182,13 @@ public:
 //! TableBinding is exactly like the Binding, except it keeps track of which columns were bound in the linked LogicalGet
 //! node for projection pushdown purposes.
 struct TableBinding : public Binding {
-	TableBinding(const string &alias, vector<LogicalType> types, vector<string> names, LogicalGet &get, idx_t index,
-	             bool add_row_id = false);
+	TableBinding(const string &alias, vector<LogicalType> types, vector<string> names,
+	             vector<column_t> &bound_column_ids, StandardEntry *entry, idx_t index, bool add_row_id = false);
 
-	//! the underlying LogicalGet
-	LogicalGet &get;
+	//! A reference to the set of bound column ids
+	vector<column_t> &bound_column_ids;
+	//! The underlying catalog entry (if any)
+	StandardEntry *entry;
 
 public:
 	unique_ptr<ParsedExpression> ExpandGeneratedColumn(const string &column_name);
@@ -16176,10 +16280,10 @@ public:
 
 	//! Adds a base table with the given alias to the BindContext.
 	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
-	                  LogicalGet &get);
+	                  vector<column_t> &bound_column_ids, StandardEntry *entry);
 	//! Adds a call to a table function with the given alias to the BindContext.
 	void AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
-	                      const vector<LogicalType> &types, LogicalGet &get);
+	                      const vector<LogicalType> &types, vector<column_t> &bound_column_ids, StandardEntry *entry);
 	//! Adds a table view with a given alias to the BindContext.
 	void AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery, ViewCatalogEntry *view);
 	//! Adds a subquery with a given alias to the BindContext.
@@ -21197,6 +21301,7 @@ public:
 
 } // namespace duckdb
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -21235,9 +21340,10 @@ public:
 
 
 namespace duckdb {
+class CastFunctionSet;
 class ClientContext;
-class TableFunctionRef;
 class CompressionFunction;
+class TableFunctionRef;
 
 struct CompressionFunctionSet;
 struct DBConfig;
@@ -21329,6 +21435,7 @@ struct DBConfigOptions {
 	//! Whether unsigned extensions should be loaded
 	bool allow_unsigned_extensions = false;
 };
+
 struct DBConfig {
 	friend class DatabaseInstance;
 	friend class StorageManager;
@@ -21348,9 +21455,9 @@ public:
 	unique_ptr<Allocator> allocator;
 	//! Database configuration options
 	DBConfigOptions options;
-
 	//! Extensions made to the parser
 	vector<ParserExtension> parser_extensions;
+	//! Extensions made to the optimizer
 	vector<OptimizerExtension> optimizer_extensions;
 
 	DUCKDB_API void AddExtensionOption(string name, string description, LogicalType parameter,
@@ -21378,8 +21485,11 @@ public:
 	//! Return the compression function for the specified compression type/physical type combo
 	DUCKDB_API CompressionFunction *GetCompressionFunction(CompressionType type, PhysicalType data_type);
 
+	DUCKDB_API CastFunctionSet &GetCastFunctions();
+
 private:
 	unique_ptr<CompressionFunctionSet> compression_functions;
+	unique_ptr<CastFunctionSet> cast_functions;
 };
 
 } // namespace duckdb
@@ -22417,29 +22527,14 @@ public:
 namespace duckdb {
 
 struct CreateScalarFunctionInfo : public CreateFunctionInfo {
-	explicit CreateScalarFunctionInfo(ScalarFunction function)
-	    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(function.name) {
-		name = function.name;
-		functions.AddFunction(move(function));
-	}
-	explicit CreateScalarFunctionInfo(ScalarFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(move(set)) {
-		name = functions.name;
-		for (auto &func : functions.functions) {
-			func.name = functions.name;
-		}
-	}
+	DUCKDB_API explicit CreateScalarFunctionInfo(ScalarFunction function);
+	DUCKDB_API explicit CreateScalarFunctionInfo(ScalarFunctionSet set);
 
 	ScalarFunctionSet functions;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		ScalarFunctionSet set(name);
-		set.functions = functions.functions;
-		auto result = make_unique<CreateScalarFunctionInfo>(move(set));
-		CopyProperties(*result);
-		return move(result);
-	}
+	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
+	DUCKDB_API unique_ptr<AlterInfo> GetAlterInfo() const override;
 };
 
 } // namespace duckdb
@@ -22450,12 +22545,13 @@ namespace duckdb {
 //! A table function in the catalog
 class ScalarFunctionCatalogEntry : public StandardEntry {
 public:
-	ScalarFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateScalarFunctionInfo *info)
-	    : StandardEntry(CatalogType::SCALAR_FUNCTION_ENTRY, schema, catalog, info->name), functions(info->functions) {
-	}
+	ScalarFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateScalarFunctionInfo *info);
 
 	//! The scalar functions
 	ScalarFunctionSet functions;
+
+public:
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -23154,6 +23250,45 @@ enum IndexConstraintType : uint8_t {
 } // namespace duckdb
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/sort/sort.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/sort/sorted_block.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/row_layout.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/aggregate/aggregate_object.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
 
 
@@ -23305,10 +23440,144 @@ private:
 };
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
+
+
+namespace duckdb {
+
+class BoundAggregateExpression;
+
+struct AggregateObject {
+	AggregateObject(AggregateFunction function, FunctionData *bind_data, idx_t child_count, idx_t payload_size,
+	                bool distinct, PhysicalType return_type, Expression *filter = nullptr);
+	AggregateObject(BoundAggregateExpression *aggr);
+
+	AggregateFunction function;
+	FunctionData *bind_data;
+	idx_t child_count;
+	idx_t payload_size;
+	bool distinct;
+	PhysicalType return_type;
+	Expression *filter = nullptr;
+
+	static vector<AggregateObject> CreateAggregateObjects(const vector<BoundAggregateExpression *> &bindings);
+};
+
+struct AggregateFilterData {
+	AggregateFilterData(Allocator &allocator, Expression &filter_expr, const vector<LogicalType> &payload_types);
+
+	idx_t ApplyFilter(DataChunk &payload);
+
+	ExpressionExecutor filter_executor;
+	DataChunk filtered_payload;
+	SelectionVector true_sel;
+};
+
+struct AggregateFilterDataSet {
+	AggregateFilterDataSet();
+
+	vector<unique_ptr<AggregateFilterData>> filter_data;
+
+public:
+	void Initialize(Allocator &allocator, const vector<AggregateObject> &aggregates,
+	                const vector<LogicalType> &payload_types);
+
+	AggregateFilterData &GetFilterData(idx_t aggr_idx);
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+class RowLayout {
+public:
+	using Aggregates = vector<AggregateObject>;
+	using ValidityBytes = TemplatedValidityMask<uint8_t>;
+
+	//! Creates an empty RowLayout
+	RowLayout();
+
+public:
+	//! Initializes the RowLayout with the specified types and aggregates to an empty RowLayout
+	void Initialize(vector<LogicalType> types_p, Aggregates aggregates_p, bool align = true);
+	//! Initializes the RowLayout with the specified types to an empty RowLayout
+	void Initialize(vector<LogicalType> types, bool align = true);
+	//! Initializes the RowLayout with the specified aggregates to an empty RowLayout
+	void Initialize(Aggregates aggregates_p, bool align = true);
+	//! Returns the number of data columns
+	inline idx_t ColumnCount() const {
+		return types.size();
+	}
+	//! Returns a list of the column types for this data chunk
+	inline const vector<LogicalType> &GetTypes() const {
+		return types;
+	}
+	//! Returns the number of aggregates
+	inline idx_t AggregateCount() const {
+		return aggregates.size();
+	}
+	//! Returns a list of the aggregates for this data chunk
+	inline Aggregates &GetAggregates() {
+		return aggregates;
+	}
+	//! Returns the total width required for each row, including padding
+	inline idx_t GetRowWidth() const {
+		return row_width;
+	}
+	//! Returns the offset to the start of the data
+	inline idx_t GetDataOffset() const {
+		return flag_width;
+	}
+	//! Returns the total width required for the data, including padding
+	inline idx_t GetDataWidth() const {
+		return data_width;
+	}
+	//! Returns the offset to the start of the aggregates
+	inline idx_t GetAggrOffset() const {
+		return flag_width + data_width;
+	}
+	//! Returns the total width required for the aggregates, including padding
+	inline idx_t GetAggrWidth() const {
+		return aggr_width;
+	}
+	//! Returns the column offsets into each row
+	inline const vector<idx_t> &GetOffsets() const {
+		return offsets;
+	}
+	//! Returns whether all columns in this layout are constant size
+	inline bool AllConstant() const {
+		return all_constant;
+	}
+	inline idx_t GetHeapOffset() const {
+		return heap_pointer_offset;
+	}
+
+private:
+	//! The types of the data columns
+	vector<LogicalType> types;
+	//! The aggregate functions
+	Aggregates aggregates;
+	//! The width of the validity header
+	idx_t flag_width;
+	//! The width of the data portion
+	idx_t data_width;
+	//! The width of the aggregate state portion
+	idx_t aggr_width;
+	//! The width of the entire row
+	idx_t row_width;
+	//! The offsets to the columns and aggregate data in each row
+	vector<idx_t> offsets;
+	//! Whether all columns in this layout are constant size
+	bool all_constant;
+	//! Offset to the pointer to the heap for each row
+	idx_t heap_pointer_offset;
+};
+
+} // namespace duckdb
+
 //                         DuckDB
 //
-// duckdb/storage/meta_block_writer.hpp
+// duckdb/common/fast_mem.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23318,10 +23587,692 @@ private:
 
 
 
+template <size_t SIZE>
+static inline void MemcpyFixed(void *dest, const void *src) {
+	memcpy(dest, src, SIZE);
+}
+
+template <size_t SIZE>
+static inline int MemcmpFixed(const void *str1, const void *str2) {
+	return memcmp(str1, str2, SIZE);
+}
+
+namespace duckdb {
+
+//! This templated memcpy is significantly faster than std::memcpy,
+//! but only when you are calling memcpy with a const size in a loop.
+//! For instance `while (<cond>) { memcpy(<dest>, <src>, const_size); ... }`
+static inline void FastMemcpy(void *dest, const void *src, const size_t size) {
+	// LCOV_EXCL_START
+	switch (size) {
+	case 0:
+		return;
+	case 1:
+		return MemcpyFixed<1>(dest, src);
+	case 2:
+		return MemcpyFixed<2>(dest, src);
+	case 3:
+		return MemcpyFixed<3>(dest, src);
+	case 4:
+		return MemcpyFixed<4>(dest, src);
+	case 5:
+		return MemcpyFixed<5>(dest, src);
+	case 6:
+		return MemcpyFixed<6>(dest, src);
+	case 7:
+		return MemcpyFixed<7>(dest, src);
+	case 8:
+		return MemcpyFixed<8>(dest, src);
+	case 9:
+		return MemcpyFixed<9>(dest, src);
+	case 10:
+		return MemcpyFixed<10>(dest, src);
+	case 11:
+		return MemcpyFixed<11>(dest, src);
+	case 12:
+		return MemcpyFixed<12>(dest, src);
+	case 13:
+		return MemcpyFixed<13>(dest, src);
+	case 14:
+		return MemcpyFixed<14>(dest, src);
+	case 15:
+		return MemcpyFixed<15>(dest, src);
+	case 16:
+		return MemcpyFixed<16>(dest, src);
+	case 17:
+		return MemcpyFixed<17>(dest, src);
+	case 18:
+		return MemcpyFixed<18>(dest, src);
+	case 19:
+		return MemcpyFixed<19>(dest, src);
+	case 20:
+		return MemcpyFixed<20>(dest, src);
+	case 21:
+		return MemcpyFixed<21>(dest, src);
+	case 22:
+		return MemcpyFixed<22>(dest, src);
+	case 23:
+		return MemcpyFixed<23>(dest, src);
+	case 24:
+		return MemcpyFixed<24>(dest, src);
+	case 25:
+		return MemcpyFixed<25>(dest, src);
+	case 26:
+		return MemcpyFixed<26>(dest, src);
+	case 27:
+		return MemcpyFixed<27>(dest, src);
+	case 28:
+		return MemcpyFixed<28>(dest, src);
+	case 29:
+		return MemcpyFixed<29>(dest, src);
+	case 30:
+		return MemcpyFixed<30>(dest, src);
+	case 31:
+		return MemcpyFixed<31>(dest, src);
+	case 32:
+		return MemcpyFixed<32>(dest, src);
+	case 33:
+		return MemcpyFixed<33>(dest, src);
+	case 34:
+		return MemcpyFixed<34>(dest, src);
+	case 35:
+		return MemcpyFixed<35>(dest, src);
+	case 36:
+		return MemcpyFixed<36>(dest, src);
+	case 37:
+		return MemcpyFixed<37>(dest, src);
+	case 38:
+		return MemcpyFixed<38>(dest, src);
+	case 39:
+		return MemcpyFixed<39>(dest, src);
+	case 40:
+		return MemcpyFixed<40>(dest, src);
+	case 41:
+		return MemcpyFixed<41>(dest, src);
+	case 42:
+		return MemcpyFixed<42>(dest, src);
+	case 43:
+		return MemcpyFixed<43>(dest, src);
+	case 44:
+		return MemcpyFixed<44>(dest, src);
+	case 45:
+		return MemcpyFixed<45>(dest, src);
+	case 46:
+		return MemcpyFixed<46>(dest, src);
+	case 47:
+		return MemcpyFixed<47>(dest, src);
+	case 48:
+		return MemcpyFixed<48>(dest, src);
+	case 49:
+		return MemcpyFixed<49>(dest, src);
+	case 50:
+		return MemcpyFixed<50>(dest, src);
+	case 51:
+		return MemcpyFixed<51>(dest, src);
+	case 52:
+		return MemcpyFixed<52>(dest, src);
+	case 53:
+		return MemcpyFixed<53>(dest, src);
+	case 54:
+		return MemcpyFixed<54>(dest, src);
+	case 55:
+		return MemcpyFixed<55>(dest, src);
+	case 56:
+		return MemcpyFixed<56>(dest, src);
+	case 57:
+		return MemcpyFixed<57>(dest, src);
+	case 58:
+		return MemcpyFixed<58>(dest, src);
+	case 59:
+		return MemcpyFixed<59>(dest, src);
+	case 60:
+		return MemcpyFixed<60>(dest, src);
+	case 61:
+		return MemcpyFixed<61>(dest, src);
+	case 62:
+		return MemcpyFixed<62>(dest, src);
+	case 63:
+		return MemcpyFixed<63>(dest, src);
+	case 64:
+		return MemcpyFixed<64>(dest, src);
+	case 65:
+		return MemcpyFixed<65>(dest, src);
+	case 66:
+		return MemcpyFixed<66>(dest, src);
+	case 67:
+		return MemcpyFixed<67>(dest, src);
+	case 68:
+		return MemcpyFixed<68>(dest, src);
+	case 69:
+		return MemcpyFixed<69>(dest, src);
+	case 70:
+		return MemcpyFixed<70>(dest, src);
+	case 71:
+		return MemcpyFixed<71>(dest, src);
+	case 72:
+		return MemcpyFixed<72>(dest, src);
+	case 73:
+		return MemcpyFixed<73>(dest, src);
+	case 74:
+		return MemcpyFixed<74>(dest, src);
+	case 75:
+		return MemcpyFixed<75>(dest, src);
+	case 76:
+		return MemcpyFixed<76>(dest, src);
+	case 77:
+		return MemcpyFixed<77>(dest, src);
+	case 78:
+		return MemcpyFixed<78>(dest, src);
+	case 79:
+		return MemcpyFixed<79>(dest, src);
+	case 80:
+		return MemcpyFixed<80>(dest, src);
+	case 81:
+		return MemcpyFixed<81>(dest, src);
+	case 82:
+		return MemcpyFixed<82>(dest, src);
+	case 83:
+		return MemcpyFixed<83>(dest, src);
+	case 84:
+		return MemcpyFixed<84>(dest, src);
+	case 85:
+		return MemcpyFixed<85>(dest, src);
+	case 86:
+		return MemcpyFixed<86>(dest, src);
+	case 87:
+		return MemcpyFixed<87>(dest, src);
+	case 88:
+		return MemcpyFixed<88>(dest, src);
+	case 89:
+		return MemcpyFixed<89>(dest, src);
+	case 90:
+		return MemcpyFixed<90>(dest, src);
+	case 91:
+		return MemcpyFixed<91>(dest, src);
+	case 92:
+		return MemcpyFixed<92>(dest, src);
+	case 93:
+		return MemcpyFixed<93>(dest, src);
+	case 94:
+		return MemcpyFixed<94>(dest, src);
+	case 95:
+		return MemcpyFixed<95>(dest, src);
+	case 96:
+		return MemcpyFixed<96>(dest, src);
+	case 97:
+		return MemcpyFixed<97>(dest, src);
+	case 98:
+		return MemcpyFixed<98>(dest, src);
+	case 99:
+		return MemcpyFixed<99>(dest, src);
+	case 100:
+		return MemcpyFixed<100>(dest, src);
+	case 101:
+		return MemcpyFixed<101>(dest, src);
+	case 102:
+		return MemcpyFixed<102>(dest, src);
+	case 103:
+		return MemcpyFixed<103>(dest, src);
+	case 104:
+		return MemcpyFixed<104>(dest, src);
+	case 105:
+		return MemcpyFixed<105>(dest, src);
+	case 106:
+		return MemcpyFixed<106>(dest, src);
+	case 107:
+		return MemcpyFixed<107>(dest, src);
+	case 108:
+		return MemcpyFixed<108>(dest, src);
+	case 109:
+		return MemcpyFixed<109>(dest, src);
+	case 110:
+		return MemcpyFixed<110>(dest, src);
+	case 111:
+		return MemcpyFixed<111>(dest, src);
+	case 112:
+		return MemcpyFixed<112>(dest, src);
+	case 113:
+		return MemcpyFixed<113>(dest, src);
+	case 114:
+		return MemcpyFixed<114>(dest, src);
+	case 115:
+		return MemcpyFixed<115>(dest, src);
+	case 116:
+		return MemcpyFixed<116>(dest, src);
+	case 117:
+		return MemcpyFixed<117>(dest, src);
+	case 118:
+		return MemcpyFixed<118>(dest, src);
+	case 119:
+		return MemcpyFixed<119>(dest, src);
+	case 120:
+		return MemcpyFixed<120>(dest, src);
+	case 121:
+		return MemcpyFixed<121>(dest, src);
+	case 122:
+		return MemcpyFixed<122>(dest, src);
+	case 123:
+		return MemcpyFixed<123>(dest, src);
+	case 124:
+		return MemcpyFixed<124>(dest, src);
+	case 125:
+		return MemcpyFixed<125>(dest, src);
+	case 126:
+		return MemcpyFixed<126>(dest, src);
+	case 127:
+		return MemcpyFixed<127>(dest, src);
+	case 128:
+		return MemcpyFixed<128>(dest, src);
+	case 129:
+		return MemcpyFixed<129>(dest, src);
+	case 130:
+		return MemcpyFixed<130>(dest, src);
+	case 131:
+		return MemcpyFixed<131>(dest, src);
+	case 132:
+		return MemcpyFixed<132>(dest, src);
+	case 133:
+		return MemcpyFixed<133>(dest, src);
+	case 134:
+		return MemcpyFixed<134>(dest, src);
+	case 135:
+		return MemcpyFixed<135>(dest, src);
+	case 136:
+		return MemcpyFixed<136>(dest, src);
+	case 137:
+		return MemcpyFixed<137>(dest, src);
+	case 138:
+		return MemcpyFixed<138>(dest, src);
+	case 139:
+		return MemcpyFixed<139>(dest, src);
+	case 140:
+		return MemcpyFixed<140>(dest, src);
+	case 141:
+		return MemcpyFixed<141>(dest, src);
+	case 142:
+		return MemcpyFixed<142>(dest, src);
+	case 143:
+		return MemcpyFixed<143>(dest, src);
+	case 144:
+		return MemcpyFixed<144>(dest, src);
+	case 145:
+		return MemcpyFixed<145>(dest, src);
+	case 146:
+		return MemcpyFixed<146>(dest, src);
+	case 147:
+		return MemcpyFixed<147>(dest, src);
+	case 148:
+		return MemcpyFixed<148>(dest, src);
+	case 149:
+		return MemcpyFixed<149>(dest, src);
+	case 150:
+		return MemcpyFixed<150>(dest, src);
+	case 151:
+		return MemcpyFixed<151>(dest, src);
+	case 152:
+		return MemcpyFixed<152>(dest, src);
+	case 153:
+		return MemcpyFixed<153>(dest, src);
+	case 154:
+		return MemcpyFixed<154>(dest, src);
+	case 155:
+		return MemcpyFixed<155>(dest, src);
+	case 156:
+		return MemcpyFixed<156>(dest, src);
+	case 157:
+		return MemcpyFixed<157>(dest, src);
+	case 158:
+		return MemcpyFixed<158>(dest, src);
+	case 159:
+		return MemcpyFixed<159>(dest, src);
+	case 160:
+		return MemcpyFixed<160>(dest, src);
+	case 161:
+		return MemcpyFixed<161>(dest, src);
+	case 162:
+		return MemcpyFixed<162>(dest, src);
+	case 163:
+		return MemcpyFixed<163>(dest, src);
+	case 164:
+		return MemcpyFixed<164>(dest, src);
+	case 165:
+		return MemcpyFixed<165>(dest, src);
+	case 166:
+		return MemcpyFixed<166>(dest, src);
+	case 167:
+		return MemcpyFixed<167>(dest, src);
+	case 168:
+		return MemcpyFixed<168>(dest, src);
+	case 169:
+		return MemcpyFixed<169>(dest, src);
+	case 170:
+		return MemcpyFixed<170>(dest, src);
+	case 171:
+		return MemcpyFixed<171>(dest, src);
+	case 172:
+		return MemcpyFixed<172>(dest, src);
+	case 173:
+		return MemcpyFixed<173>(dest, src);
+	case 174:
+		return MemcpyFixed<174>(dest, src);
+	case 175:
+		return MemcpyFixed<175>(dest, src);
+	case 176:
+		return MemcpyFixed<176>(dest, src);
+	case 177:
+		return MemcpyFixed<177>(dest, src);
+	case 178:
+		return MemcpyFixed<178>(dest, src);
+	case 179:
+		return MemcpyFixed<179>(dest, src);
+	case 180:
+		return MemcpyFixed<180>(dest, src);
+	case 181:
+		return MemcpyFixed<181>(dest, src);
+	case 182:
+		return MemcpyFixed<182>(dest, src);
+	case 183:
+		return MemcpyFixed<183>(dest, src);
+	case 184:
+		return MemcpyFixed<184>(dest, src);
+	case 185:
+		return MemcpyFixed<185>(dest, src);
+	case 186:
+		return MemcpyFixed<186>(dest, src);
+	case 187:
+		return MemcpyFixed<187>(dest, src);
+	case 188:
+		return MemcpyFixed<188>(dest, src);
+	case 189:
+		return MemcpyFixed<189>(dest, src);
+	case 190:
+		return MemcpyFixed<190>(dest, src);
+	case 191:
+		return MemcpyFixed<191>(dest, src);
+	case 192:
+		return MemcpyFixed<192>(dest, src);
+	case 193:
+		return MemcpyFixed<193>(dest, src);
+	case 194:
+		return MemcpyFixed<194>(dest, src);
+	case 195:
+		return MemcpyFixed<195>(dest, src);
+	case 196:
+		return MemcpyFixed<196>(dest, src);
+	case 197:
+		return MemcpyFixed<197>(dest, src);
+	case 198:
+		return MemcpyFixed<198>(dest, src);
+	case 199:
+		return MemcpyFixed<199>(dest, src);
+	case 200:
+		return MemcpyFixed<200>(dest, src);
+	case 201:
+		return MemcpyFixed<201>(dest, src);
+	case 202:
+		return MemcpyFixed<202>(dest, src);
+	case 203:
+		return MemcpyFixed<203>(dest, src);
+	case 204:
+		return MemcpyFixed<204>(dest, src);
+	case 205:
+		return MemcpyFixed<205>(dest, src);
+	case 206:
+		return MemcpyFixed<206>(dest, src);
+	case 207:
+		return MemcpyFixed<207>(dest, src);
+	case 208:
+		return MemcpyFixed<208>(dest, src);
+	case 209:
+		return MemcpyFixed<209>(dest, src);
+	case 210:
+		return MemcpyFixed<210>(dest, src);
+	case 211:
+		return MemcpyFixed<211>(dest, src);
+	case 212:
+		return MemcpyFixed<212>(dest, src);
+	case 213:
+		return MemcpyFixed<213>(dest, src);
+	case 214:
+		return MemcpyFixed<214>(dest, src);
+	case 215:
+		return MemcpyFixed<215>(dest, src);
+	case 216:
+		return MemcpyFixed<216>(dest, src);
+	case 217:
+		return MemcpyFixed<217>(dest, src);
+	case 218:
+		return MemcpyFixed<218>(dest, src);
+	case 219:
+		return MemcpyFixed<219>(dest, src);
+	case 220:
+		return MemcpyFixed<220>(dest, src);
+	case 221:
+		return MemcpyFixed<221>(dest, src);
+	case 222:
+		return MemcpyFixed<222>(dest, src);
+	case 223:
+		return MemcpyFixed<223>(dest, src);
+	case 224:
+		return MemcpyFixed<224>(dest, src);
+	case 225:
+		return MemcpyFixed<225>(dest, src);
+	case 226:
+		return MemcpyFixed<226>(dest, src);
+	case 227:
+		return MemcpyFixed<227>(dest, src);
+	case 228:
+		return MemcpyFixed<228>(dest, src);
+	case 229:
+		return MemcpyFixed<229>(dest, src);
+	case 230:
+		return MemcpyFixed<230>(dest, src);
+	case 231:
+		return MemcpyFixed<231>(dest, src);
+	case 232:
+		return MemcpyFixed<232>(dest, src);
+	case 233:
+		return MemcpyFixed<233>(dest, src);
+	case 234:
+		return MemcpyFixed<234>(dest, src);
+	case 235:
+		return MemcpyFixed<235>(dest, src);
+	case 236:
+		return MemcpyFixed<236>(dest, src);
+	case 237:
+		return MemcpyFixed<237>(dest, src);
+	case 238:
+		return MemcpyFixed<238>(dest, src);
+	case 239:
+		return MemcpyFixed<239>(dest, src);
+	case 240:
+		return MemcpyFixed<240>(dest, src);
+	case 241:
+		return MemcpyFixed<241>(dest, src);
+	case 242:
+		return MemcpyFixed<242>(dest, src);
+	case 243:
+		return MemcpyFixed<243>(dest, src);
+	case 244:
+		return MemcpyFixed<244>(dest, src);
+	case 245:
+		return MemcpyFixed<245>(dest, src);
+	case 246:
+		return MemcpyFixed<246>(dest, src);
+	case 247:
+		return MemcpyFixed<247>(dest, src);
+	case 248:
+		return MemcpyFixed<248>(dest, src);
+	case 249:
+		return MemcpyFixed<249>(dest, src);
+	case 250:
+		return MemcpyFixed<250>(dest, src);
+	case 251:
+		return MemcpyFixed<251>(dest, src);
+	case 252:
+		return MemcpyFixed<252>(dest, src);
+	case 253:
+		return MemcpyFixed<253>(dest, src);
+	case 254:
+		return MemcpyFixed<254>(dest, src);
+	case 255:
+		return MemcpyFixed<255>(dest, src);
+	case 256:
+		return MemcpyFixed<256>(dest, src);
+	default:
+		memcpy(dest, src, size);
+	}
+	// LCOV_EXCL_STOP
+}
+
+//! This templated memcmp is significantly faster than std::memcmp,
+//! but only when you are calling memcmp with a const size in a loop.
+//! For instance `while (<cond>) { memcmp(<str1>, <str2>, const_size); ... }`
+static inline int FastMemcmp(const void *str1, const void *str2, const size_t size) {
+	// LCOV_EXCL_START
+	switch (size) {
+	case 0:
+		return 0;
+	case 1:
+		return MemcmpFixed<1>(str1, str2);
+	case 2:
+		return MemcmpFixed<2>(str1, str2);
+	case 3:
+		return MemcmpFixed<3>(str1, str2);
+	case 4:
+		return MemcmpFixed<4>(str1, str2);
+	case 5:
+		return MemcmpFixed<5>(str1, str2);
+	case 6:
+		return MemcmpFixed<6>(str1, str2);
+	case 7:
+		return MemcmpFixed<7>(str1, str2);
+	case 8:
+		return MemcmpFixed<8>(str1, str2);
+	case 9:
+		return MemcmpFixed<9>(str1, str2);
+	case 10:
+		return MemcmpFixed<10>(str1, str2);
+	case 11:
+		return MemcmpFixed<11>(str1, str2);
+	case 12:
+		return MemcmpFixed<12>(str1, str2);
+	case 13:
+		return MemcmpFixed<13>(str1, str2);
+	case 14:
+		return MemcmpFixed<14>(str1, str2);
+	case 15:
+		return MemcmpFixed<15>(str1, str2);
+	case 16:
+		return MemcmpFixed<16>(str1, str2);
+	case 17:
+		return MemcmpFixed<17>(str1, str2);
+	case 18:
+		return MemcmpFixed<18>(str1, str2);
+	case 19:
+		return MemcmpFixed<19>(str1, str2);
+	case 20:
+		return MemcmpFixed<20>(str1, str2);
+	case 21:
+		return MemcmpFixed<21>(str1, str2);
+	case 22:
+		return MemcmpFixed<22>(str1, str2);
+	case 23:
+		return MemcmpFixed<23>(str1, str2);
+	case 24:
+		return MemcmpFixed<24>(str1, str2);
+	case 25:
+		return MemcmpFixed<25>(str1, str2);
+	case 26:
+		return MemcmpFixed<26>(str1, str2);
+	case 27:
+		return MemcmpFixed<27>(str1, str2);
+	case 28:
+		return MemcmpFixed<28>(str1, str2);
+	case 29:
+		return MemcmpFixed<29>(str1, str2);
+	case 30:
+		return MemcmpFixed<30>(str1, str2);
+	case 31:
+		return MemcmpFixed<31>(str1, str2);
+	case 32:
+		return MemcmpFixed<32>(str1, str2);
+	case 33:
+		return MemcmpFixed<33>(str1, str2);
+	case 34:
+		return MemcmpFixed<34>(str1, str2);
+	case 35:
+		return MemcmpFixed<35>(str1, str2);
+	case 36:
+		return MemcmpFixed<36>(str1, str2);
+	case 37:
+		return MemcmpFixed<37>(str1, str2);
+	case 38:
+		return MemcmpFixed<38>(str1, str2);
+	case 39:
+		return MemcmpFixed<39>(str1, str2);
+	case 40:
+		return MemcmpFixed<40>(str1, str2);
+	case 41:
+		return MemcmpFixed<41>(str1, str2);
+	case 42:
+		return MemcmpFixed<42>(str1, str2);
+	case 43:
+		return MemcmpFixed<43>(str1, str2);
+	case 44:
+		return MemcmpFixed<44>(str1, str2);
+	case 45:
+		return MemcmpFixed<45>(str1, str2);
+	case 46:
+		return MemcmpFixed<46>(str1, str2);
+	case 47:
+		return MemcmpFixed<47>(str1, str2);
+	case 48:
+		return MemcmpFixed<48>(str1, str2);
+	case 49:
+		return MemcmpFixed<49>(str1, str2);
+	case 50:
+		return MemcmpFixed<50>(str1, str2);
+	case 51:
+		return MemcmpFixed<51>(str1, str2);
+	case 52:
+		return MemcmpFixed<52>(str1, str2);
+	case 53:
+		return MemcmpFixed<53>(str1, str2);
+	case 54:
+		return MemcmpFixed<54>(str1, str2);
+	case 55:
+		return MemcmpFixed<55>(str1, str2);
+	case 56:
+		return MemcmpFixed<56>(str1, str2);
+	case 57:
+		return MemcmpFixed<57>(str1, str2);
+	case 58:
+		return MemcmpFixed<58>(str1, str2);
+	case 59:
+		return MemcmpFixed<59>(str1, str2);
+	case 60:
+		return MemcmpFixed<60>(str1, str2);
+	case 61:
+		return MemcmpFixed<61>(str1, str2);
+	case 62:
+		return MemcmpFixed<62>(str1, str2);
+	case 63:
+		return MemcmpFixed<63>(str1, str2);
+	case 64:
+		return MemcmpFixed<64>(str1, str2);
+	default:
+		return memcmp(str1, str2, size);
+	}
+	// LCOV_EXCL_STOP
+}
+
+} // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/storage/block_manager.hpp
+// duckdb/common/sort/comparators.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23331,65 +24282,957 @@ private:
 
 
 
-
 namespace duckdb {
-class ClientContext;
-class DatabaseInstance;
 
-//! BlockManager is an abstract representation to manage blocks on DuckDB. When writing or reading blocks, the
-//! BlockManager creates and accesses blocks. The concrete types implements how blocks are stored.
-class BlockManager {
+struct SortLayout;
+struct SBScanState;
+
+using ValidityBytes = RowLayout::ValidityBytes;
+
+struct Comparators {
 public:
-	virtual ~BlockManager() = default;
+	//! Whether a tie between two blobs can be broken
+	static bool TieIsBreakable(const idx_t &col_idx, const data_ptr_t row_ptr, const RowLayout &row_layout);
+	//! Compares the tuples that a being read from in the 'left' and 'right blocks during merge sort
+	//! (only in case we cannot simply 'memcmp' - if there are blob columns)
+	static int CompareTuple(const SBScanState &left, const SBScanState &right, const data_ptr_t &l_ptr,
+	                        const data_ptr_t &r_ptr, const SortLayout &sort_layout, const bool &external_sort);
+	//! Compare two blob values
+	static int CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, const LogicalType &type);
 
-	virtual void StartCheckpoint() = 0;
-	//! Creates a new block inside the block manager
-	virtual unique_ptr<Block> CreateBlock(block_id_t block_id) = 0;
-	//! Return the next free block id
-	virtual block_id_t GetFreeBlockId() = 0;
-	//! Returns whether or not a specified block is the root block
-	virtual bool IsRootBlock(block_id_t root) = 0;
-	//! Mark a block as "modified"; modified blocks are added to the free list after a checkpoint (i.e. their data is
-	//! assumed to be rewritten)
-	virtual void MarkBlockAsModified(block_id_t block_id) = 0;
-	//! Increase the reference count of a block. The block should hold at least one reference before this method is
-	//! called.
-	virtual void IncreaseBlockReferenceCount(block_id_t block_id) = 0;
-	//! Get the first meta block id
-	virtual block_id_t GetMetaBlock() = 0;
-	//! Read the content of the block from disk
-	virtual void Read(Block &block) = 0;
-	//! Writes the block to disk
-	virtual void Write(FileBuffer &block, block_id_t block_id) = 0;
-	//! Writes the block to disk
-	void Write(Block &block) {
-		Write(block, block.id);
-	}
-	//! Write the header; should be the final step of a checkpoint
-	virtual void WriteHeader(DatabaseHeader header) = 0;
+private:
+	//! Compares two blob values that were initially tied by their prefix
+	static int BreakBlobTie(const idx_t &tie_col, const SBScanState &left, const SBScanState &right,
+	                        const SortLayout &sort_layout, const bool &external);
+	//! Compare two fixed-size values
+	template <class T>
+	static int TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_t &right_ptr);
 
-	//! Returns the number of total blocks
-	virtual idx_t TotalBlocks() = 0;
-	//! Returns the number of free blocks
-	virtual idx_t FreeBlocks() = 0;
+	//! Compare two values at the pointers (can be recursive if nested type)
+	static int CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type);
+	//! Compares two fixed-size values at the given pointers
+	template <class T>
+	static int TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr);
+	//! Compares two string values at the given pointers
+	static int CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr);
+	//! Compares two struct values at the given pointers (recursive)
+	static int CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
+	                                   const child_list_t<LogicalType> &types);
+	//! Compare two list values at the pointers (can be recursive if nested type)
+	static int CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type);
+	//! Compares a list of fixed-size values
+	template <class T>
+	static int TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const ValidityBytes &left_validity,
+	                                    const ValidityBytes &right_validity, const idx_t &count);
 
-	static BlockManager &GetBlockManager(ClientContext &context);
-	static BlockManager &GetBlockManager(DatabaseInstance &db);
+	//! Unwizzles an offset into a pointer
+	static void UnswizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type);
+	//! Swizzles a pointer into an offset
+	static void SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type);
 };
+
 } // namespace duckdb
 
 
 
 namespace duckdb {
-class DatabaseInstance;
 
-//! This struct is responsible for writing metadata to disk
-class MetaBlockWriter : public Serializer {
-public:
-	MetaBlockWriter(DatabaseInstance &db, block_id_t initial_block_id = INVALID_BLOCK);
-	~MetaBlockWriter() override;
+class BufferManager;
+struct RowDataBlock;
+struct SortLayout;
+struct GlobalSortState;
 
-	DatabaseInstance &db;
+enum class SortedDataType { BLOB, PAYLOAD };
+
+//! Object that holds sorted rows, and an accompanying heap if there are blobs
+struct SortedData {
+public:
+	SortedData(SortedDataType type, const RowLayout &layout, BufferManager &buffer_manager, GlobalSortState &state);
+	//! Number of rows that this object holds
+	idx_t Count();
+	//! Initialize new block to write to
+	void CreateBlock();
+	//! Create a slice that holds the rows between the start and end indices
+	unique_ptr<SortedData> CreateSlice(idx_t start_block_index, idx_t end_block_index, idx_t end_entry_index);
+	//! Unswizzles all
+	void Unswizzle();
+
+public:
+	const SortedDataType type;
+	//! Layout of this data
+	const RowLayout layout;
+	//! Data and heap blocks
+	vector<unique_ptr<RowDataBlock>> data_blocks;
+	vector<unique_ptr<RowDataBlock>> heap_blocks;
+	//! Whether the pointers in this sorted data are swizzled
+	bool swizzled;
+
+private:
+	//! The buffer manager
+	BufferManager &buffer_manager;
+	//! The global state
+	GlobalSortState &state;
+};
+
+//! Block that holds sorted rows: radix, blob and payload data
+struct SortedBlock {
+public:
+	SortedBlock(BufferManager &buffer_manager, GlobalSortState &gstate);
+	//! Number of rows that this object holds
+	idx_t Count() const;
+	//! Initialize this block to write data to
+	void InitializeWrite();
+	//! Init new block to write to
+	void CreateBlock();
+	//! Fill this sorted block by appending the blocks held by a vector of sorted blocks
+	void AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blocks);
+	//! Locate the block and entry index of a row in this block,
+	//! given an index between 0 and the total number of rows in this block
+	void GlobalToLocalIndex(const idx_t &global_idx, idx_t &local_block_index, idx_t &local_entry_index);
+	//! Create a slice that holds the rows between the start and end indices
+	unique_ptr<SortedBlock> CreateSlice(const idx_t start, const idx_t end, idx_t &entry_idx);
+
+	//! Size (in bytes) of the heap of this block
+	idx_t HeapSize() const;
+	//! Total size (in bytes) of this block
+	idx_t SizeInBytes() const;
+
+public:
+	//! Radix/memcmp sortable data
+	vector<unique_ptr<RowDataBlock>> radix_sorting_data;
+	//! Variable sized sorting data
+	unique_ptr<SortedData> blob_sorting_data;
+	//! Payload data
+	unique_ptr<SortedData> payload_data;
+
+private:
+	//! Buffer manager, global state, and sorting layout constants
+	BufferManager &buffer_manager;
+	GlobalSortState &state;
+	const SortLayout &sort_layout;
+	const RowLayout &payload_layout;
+};
+
+//! State used to scan a SortedBlock e.g. during merge sort
+struct SBScanState {
+public:
+	SBScanState(BufferManager &buffer_manager, GlobalSortState &state);
+
+	void PinRadix(idx_t block_idx_to);
+	void PinData(SortedData &sd);
+
+	data_ptr_t RadixPtr() const;
+	data_ptr_t DataPtr(SortedData &sd) const;
+	data_ptr_t HeapPtr(SortedData &sd) const;
+	data_ptr_t BaseHeapPtr(SortedData &sd) const;
+
+	idx_t Remaining() const;
+
+	void SetIndices(idx_t block_idx_to, idx_t entry_idx_to);
+
+public:
+	BufferManager &buffer_manager;
+	const SortLayout &sort_layout;
+	GlobalSortState &state;
+
+	SortedBlock *sb;
+
+	idx_t block_idx;
+	idx_t entry_idx;
+
+	BufferHandle radix_handle;
+
+	BufferHandle blob_sorting_data_handle;
+	BufferHandle blob_sorting_heap_handle;
+
+	BufferHandle payload_data_handle;
+	BufferHandle payload_heap_handle;
+};
+
+//! Used to scan the data into DataChunks after sorting
+struct PayloadScanner {
+public:
+	PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state, bool flush = true);
+	explicit PayloadScanner(GlobalSortState &global_sort_state, bool flush = true);
+
+	//! Scan a single block
+	PayloadScanner(GlobalSortState &global_sort_state, idx_t block_idx);
+
+	//! The type layout of the payload
+	inline const vector<LogicalType> &GetPayloadTypes() const {
+		return sorted_data.layout.GetTypes();
+	}
+
+	//! The number of rows scanned so far
+	inline idx_t Scanned() const {
+		return total_scanned;
+	}
+
+	//! The number of remaining rows
+	inline idx_t Remaining() const {
+		return total_count - total_scanned;
+	}
+
+	//! Scans the next data chunk from the sorted data
+	void Scan(DataChunk &chunk);
+
+private:
+	//! The sorted data being scanned
+	SortedData &sorted_data;
+	//! Read state
+	SBScanState read_state;
+	//! The total count of sorted_data
+	const idx_t total_count;
+	//! Addresses used to gather from the sorted data
+	Vector addresses = Vector(LogicalType::POINTER);
+	//! The number of rows scanned so far
+	idx_t total_scanned;
+	//! Whether to flush the blocks after scanning
+	const bool flush;
+	//! Whether we are unswizzling the blocks
+	const bool unswizzling;
+
+	//! Checks that the newest block is valid
+	void ValidateUnscannedBlock() const;
+};
+
+struct SBIterator {
+	static int ComparisonValue(ExpressionType comparison);
+
+	SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p = 0);
+
+	inline idx_t GetIndex() const {
+		return entry_idx;
+	}
+
+	inline void SetIndex(idx_t entry_idx_p) {
+		const auto new_block_idx = entry_idx_p / block_capacity;
+		if (new_block_idx != scan.block_idx) {
+			scan.SetIndices(new_block_idx, 0);
+			if (new_block_idx < block_count) {
+				scan.PinRadix(scan.block_idx);
+				block_ptr = scan.RadixPtr();
+				if (!all_constant) {
+					scan.PinData(*scan.sb->blob_sorting_data);
+				}
+			}
+		}
+
+		scan.entry_idx = entry_idx_p % block_capacity;
+		entry_ptr = block_ptr + scan.entry_idx * entry_size;
+		entry_idx = entry_idx_p;
+	}
+
+	inline SBIterator &operator++() {
+		if (++scan.entry_idx < block_capacity) {
+			entry_ptr += entry_size;
+			++entry_idx;
+		} else {
+			SetIndex(entry_idx + 1);
+		}
+
+		return *this;
+	}
+
+	inline SBIterator &operator--() {
+		if (scan.entry_idx) {
+			--scan.entry_idx;
+			--entry_idx;
+			entry_ptr -= entry_size;
+		} else {
+			SetIndex(entry_idx - 1);
+		}
+
+		return *this;
+	}
+
+	inline bool Compare(const SBIterator &other) const {
+		int comp_res;
+		if (all_constant) {
+			comp_res = FastMemcmp(entry_ptr, other.entry_ptr, cmp_size);
+		} else {
+			comp_res = Comparators::CompareTuple(scan, other.scan, entry_ptr, other.entry_ptr, sort_layout, external);
+		}
+
+		return comp_res <= cmp;
+	}
+
+	// Fixed comparison parameters
+	const SortLayout &sort_layout;
+	const idx_t block_count;
+	const idx_t block_capacity;
+	const size_t cmp_size;
+	const size_t entry_size;
+	const bool all_constant;
+	const bool external;
+	const int cmp;
+
+	// Iteration state
+	SBScanState scan;
+	idx_t entry_idx;
+	data_ptr_t block_ptr;
+	data_ptr_t entry_ptr;
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/row_data_collection.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/buffer_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/block_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+class ClientContext;
+class DatabaseInstance;
+
+//! BlockManager is an abstract representation to manage blocks on DuckDB. When writing or reading blocks, the
+//! BlockManager creates and accesses blocks. The concrete types implements how blocks are stored.
+class BlockManager {
+public:
+	virtual ~BlockManager() = default;
+
+	virtual void StartCheckpoint() = 0;
+	//! Creates a new block inside the block manager
+	virtual unique_ptr<Block> CreateBlock(block_id_t block_id) = 0;
+	//! Return the next free block id
+	virtual block_id_t GetFreeBlockId() = 0;
+	//! Returns whether or not a specified block is the root block
+	virtual bool IsRootBlock(block_id_t root) = 0;
+	//! Mark a block as "modified"; modified blocks are added to the free list after a checkpoint (i.e. their data is
+	//! assumed to be rewritten)
+	virtual void MarkBlockAsModified(block_id_t block_id) = 0;
+	//! Increase the reference count of a block. The block should hold at least one reference before this method is
+	//! called.
+	virtual void IncreaseBlockReferenceCount(block_id_t block_id) = 0;
+	//! Get the first meta block id
+	virtual block_id_t GetMetaBlock() = 0;
+	//! Read the content of the block from disk
+	virtual void Read(Block &block) = 0;
+	//! Writes the block to disk
+	virtual void Write(FileBuffer &block, block_id_t block_id) = 0;
+	//! Writes the block to disk
+	void Write(Block &block) {
+		Write(block, block.id);
+	}
+	//! Write the header; should be the final step of a checkpoint
+	virtual void WriteHeader(DatabaseHeader header) = 0;
+
+	//! Returns the number of total blocks
+	virtual idx_t TotalBlocks() = 0;
+	//! Returns the number of free blocks
+	virtual idx_t FreeBlocks() = 0;
+
+	static BlockManager &GetBlockManager(ClientContext &context);
+	static BlockManager &GetBlockManager(DatabaseInstance &db);
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/buffer/block_handle.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+class BufferHandle;
+class BufferManager;
+class DatabaseInstance;
+class FileBuffer;
+
+enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 };
+
+class BlockHandle {
+	friend struct BufferEvictionNode;
+	friend class BufferHandle;
+	friend class BufferManager;
+
+public:
+	BlockHandle(DatabaseInstance &db, block_id_t block_id);
+	BlockHandle(DatabaseInstance &db, block_id_t block_id, unique_ptr<FileBuffer> buffer, bool can_destroy,
+	            idx_t block_size);
+	~BlockHandle();
+
+	DatabaseInstance &db;
+
+public:
+	block_id_t BlockId() {
+		return block_id;
+	}
+
+	int32_t Readers() const {
+		return readers;
+	}
+
+	inline bool IsSwizzled() const {
+		return !unswizzled;
+	}
+
+	inline void SetSwizzling(const char *unswizzler) {
+		unswizzled = unswizzler;
+	}
+
+private:
+	static BufferHandle Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileBuffer> buffer = nullptr);
+	unique_ptr<FileBuffer> UnloadAndTakeBlock();
+	void Unload();
+	bool CanUnload();
+
+	//! The block-level lock
+	mutex lock;
+	//! Whether or not the block is loaded/unloaded
+	BlockState state;
+	//! Amount of concurrent readers
+	atomic<int32_t> readers;
+	//! The block id of the block
+	const block_id_t block_id;
+	//! Pointer to loaded data (if any)
+	unique_ptr<FileBuffer> buffer;
+	//! Internal eviction timestamp
+	atomic<idx_t> eviction_timestamp;
+	//! Whether or not the buffer can be destroyed (only used for temporary buffers)
+	const bool can_destroy;
+	//! The memory usage of the block
+	idx_t memory_usage;
+	//! Does the block contain any memory pointers?
+	const char *unswizzled;
+};
+
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/buffer/managed_buffer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+class DatabaseInstance;
+
+//! Managed buffer is an arbitrarily-sized buffer that is at least of size >= BLOCK_SIZE
+class ManagedBuffer : public FileBuffer {
+public:
+	ManagedBuffer(DatabaseInstance &db, idx_t size, bool can_destroy, block_id_t id);
+	ManagedBuffer(DatabaseInstance &db, FileBuffer &source, bool can_destroy, block_id_t id);
+
+	DatabaseInstance &db;
+	//! Whether or not the managed buffer can be freely destroyed when unpinned.
+	//! - If can_destroy is true, the buffer can be destroyed when unpinned and hence be unrecoverable. After being
+	//! destroyed, Pin() will return false.
+	//! - If can_destroy is false, the buffer will instead be written to a temporary file on disk when unloaded from
+	//! memory, and read back into memory when Pin() is called.
+	bool can_destroy;
+	//! The internal id of the buffer
+	block_id_t id;
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+class DatabaseInstance;
+class TemporaryDirectoryHandle;
+struct EvictionQueue;
+
+//! The buffer manager is in charge of handling memory management for the database. It hands out memory buffers that can
+//! be used by the database internally.
+class BufferManager {
+	friend class BufferHandle;
+	friend class BlockHandle;
+
+public:
+	BufferManager(DatabaseInstance &db, string temp_directory, idx_t maximum_memory);
+	~BufferManager();
+
+	//! Register a block with the given block id in the base file
+	shared_ptr<BlockHandle> RegisterBlock(block_id_t block_id);
+
+	//! Register an in-memory buffer of arbitrary size, as long as it is >= BLOCK_SIZE. can_destroy signifies whether or
+	//! not the buffer can be destroyed when unpinned, or whether or not it needs to be written to a temporary file so
+	//! it can be reloaded. The resulting buffer will already be allocated, but needs to be pinned in order to be used.
+	shared_ptr<BlockHandle> RegisterMemory(idx_t block_size, bool can_destroy);
+
+	//! Convert an existing in-memory buffer into a persistent disk-backed block
+	shared_ptr<BlockHandle> ConvertToPersistent(BlockManager &block_manager, block_id_t block_id,
+	                                            shared_ptr<BlockHandle> old_block);
+
+	//! Allocate an in-memory buffer with a single pin.
+	//! The allocated memory is released when the buffer handle is destroyed.
+	DUCKDB_API BufferHandle Allocate(idx_t block_size);
+
+	//! Reallocate an in-memory buffer that is pinned.
+	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size);
+
+	BufferHandle Pin(shared_ptr<BlockHandle> &handle);
+	void Unpin(shared_ptr<BlockHandle> &handle);
+
+	void UnregisterBlock(block_id_t block_id, bool can_destroy);
+
+	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
+	//! blocks can be evicted
+	void SetLimit(idx_t limit = (idx_t)-1);
+
+	static BufferManager &GetBufferManager(ClientContext &context);
+	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
+
+	idx_t GetUsedMemory() {
+		return current_memory;
+	}
+	idx_t GetMaxMemory() {
+		return maximum_memory;
+	}
+
+	const string &GetTemporaryDirectory() {
+		return temp_directory;
+	}
+
+	void SetTemporaryDirectory(string new_dir);
+
+	DUCKDB_API Allocator &GetBufferAllocator();
+
+private:
+	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
+	//! (i.e. not enough blocks could be evicted)
+	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
+	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
+	bool EvictBlocks(idx_t extra_memory, idx_t memory_limit, unique_ptr<FileBuffer> *buffer = nullptr);
+
+	//! Garbage collect eviction queue
+	void PurgeQueue();
+
+	//! Write a temporary buffer to disk
+	void WriteTemporaryBuffer(ManagedBuffer &buffer);
+	//! Read a temporary buffer from disk
+	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> buffer = nullptr);
+	//! Get the path of the temporary buffer
+	string GetTemporaryPath(block_id_t id);
+
+	void DeleteTemporaryFile(block_id_t id);
+
+	void RequireTemporaryDirectory();
+
+	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
+
+	string InMemoryWarning();
+
+	static data_ptr_t BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size);
+	static void BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
+	static data_ptr_t BufferAllocatorRealloc(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
+	                                         idx_t size);
+
+private:
+	//! The database instance
+	DatabaseInstance &db;
+	//! The lock for changing the memory limit
+	mutex limit_lock;
+	//! The current amount of memory that is occupied by the buffer manager (in bytes)
+	atomic<idx_t> current_memory;
+	//! The maximum amount of memory that the buffer manager can keep (in bytes)
+	atomic<idx_t> maximum_memory;
+	//! The directory name where temporary files are stored
+	string temp_directory;
+	//! Lock for creating the temp handle
+	mutex temp_handle_lock;
+	//! Handle for the temporary directory
+	unique_ptr<TemporaryDirectoryHandle> temp_directory_handle;
+	//! The lock for the set of blocks
+	mutex blocks_lock;
+	//! A mapping of block id -> BlockHandle
+	unordered_map<block_id_t, weak_ptr<BlockHandle>> blocks;
+	//! Eviction queue
+	unique_ptr<EvictionQueue> queue;
+	//! The temporary id used for managed buffers
+	atomic<block_id_t> temporary_id;
+	//! Allocator associated with the buffer manager, that passes all allocations through this buffer manager
+	Allocator buffer_allocator;
+};
+} // namespace duckdb
+
+
+namespace duckdb {
+
+struct RowDataBlock {
+public:
+	RowDataBlock(BufferManager &buffer_manager, idx_t capacity, idx_t entry_size)
+	    : capacity(capacity), entry_size(entry_size), count(0), byte_offset(0) {
+		block = buffer_manager.RegisterMemory(capacity * entry_size, false);
+	}
+	explicit RowDataBlock(idx_t entry_size) : entry_size(entry_size) {
+	}
+	//! The buffer block handle
+	shared_ptr<BlockHandle> block;
+	//! Capacity (number of entries) and entry size that fit in this block
+	idx_t capacity;
+	const idx_t entry_size;
+	//! Number of entries currently in this block
+	idx_t count;
+	//! Write offset (if variable size entries)
+	idx_t byte_offset;
+
+private:
+	//! Implicit copying is not allowed
+	RowDataBlock(const RowDataBlock &) = delete;
+
+public:
+	unique_ptr<RowDataBlock> Copy() {
+		auto result = make_unique<RowDataBlock>(entry_size);
+		result->block = block;
+		result->capacity = capacity;
+		result->count = count;
+		result->byte_offset = byte_offset;
+		return result;
+	}
+};
+
+struct BlockAppendEntry {
+	BlockAppendEntry(data_ptr_t baseptr, idx_t count) : baseptr(baseptr), count(count) {
+	}
+	data_ptr_t baseptr;
+	idx_t count;
+};
+
+class RowDataCollection {
+public:
+	RowDataCollection(BufferManager &buffer_manager, idx_t block_capacity, idx_t entry_size, bool keep_pinned = false);
+
+	unique_ptr<RowDataCollection> CloneEmpty(bool keep_pinned = false) const {
+		return make_unique<RowDataCollection>(buffer_manager, block_capacity, entry_size, keep_pinned);
+	}
+
+	//! BufferManager
+	BufferManager &buffer_manager;
+	//! The total number of stored entries
+	idx_t count;
+	//! The number of entries per block
+	idx_t block_capacity;
+	//! Size of entries in the blocks
+	idx_t entry_size;
+	//! The blocks holding the main data
+	vector<unique_ptr<RowDataBlock>> blocks;
+	//! The blocks that this collection currently has pinned
+	vector<BufferHandle> pinned_blocks;
+	//! Whether the blocks should stay pinned (necessary for e.g. a heap)
+	const bool keep_pinned;
+
+public:
+	idx_t AppendToBlock(RowDataBlock &block, BufferHandle &handle, vector<BlockAppendEntry> &append_entries,
+	                    idx_t remaining, idx_t entry_sizes[]);
+	RowDataBlock &CreateBlock();
+	vector<BufferHandle> Build(idx_t added_count, data_ptr_t key_locations[], idx_t entry_sizes[],
+	                           const SelectionVector *sel = FlatVector::IncrementalSelectionVector());
+
+	void Merge(RowDataCollection &other);
+
+	void Clear() {
+		blocks.clear();
+		pinned_blocks.clear();
+		count = 0;
+	}
+
+	//! The size (in bytes) of this RowDataCollection if it were stored in a single block
+	idx_t SizeInBytes() const {
+		idx_t bytes = 0;
+		if (entry_size == 1) {
+			for (auto &block : blocks) {
+				bytes += block->byte_offset;
+			}
+		} else {
+			bytes = count * entry_size;
+		}
+		return bytes;
+	}
+
+	static inline idx_t EntriesPerBlock(idx_t width) {
+		return (Storage::BLOCK_SIZE + width * STANDARD_VECTOR_SIZE - 1) / width;
+	}
+
+private:
+	mutex rdc_lock;
+
+	//! Copying is not allowed
+	RowDataCollection(const RowDataCollection &) = delete;
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+
+class RowLayout;
+struct LocalSortState;
+
+struct SortConstants {
+	static constexpr idx_t VALUES_PER_RADIX = 256;
+	static constexpr idx_t MSD_RADIX_LOCATIONS = VALUES_PER_RADIX + 1;
+	static constexpr idx_t INSERTION_SORT_THRESHOLD = 24;
+	static constexpr idx_t MSD_RADIX_SORT_SIZE_THRESHOLD = 4;
+};
+
+struct SortLayout {
+public:
+	SortLayout() {
+	}
+	explicit SortLayout(const vector<BoundOrderByNode> &orders);
+	SortLayout GetPrefixComparisonLayout(idx_t num_prefix_cols) const;
+
+public:
+	idx_t column_count;
+	vector<OrderType> order_types;
+	vector<OrderByNullType> order_by_null_types;
+	vector<LogicalType> logical_types;
+
+	bool all_constant;
+	vector<bool> constant_size;
+	vector<idx_t> column_sizes;
+	vector<idx_t> prefix_lengths;
+	vector<BaseStatistics *> stats;
+	vector<bool> has_null;
+
+	idx_t comparison_size;
+	idx_t entry_size;
+
+	RowLayout blob_layout;
+	unordered_map<idx_t, idx_t> sorting_to_blob_col;
+};
+
+struct GlobalSortState {
+public:
+	GlobalSortState(BufferManager &buffer_manager, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout);
+
+	//! Add local state sorted data to this global state
+	void AddLocalState(LocalSortState &local_sort_state);
+	//! Prepares the GlobalSortState for the merge sort phase (after completing radix sort phase)
+	void PrepareMergePhase();
+	//! Initializes the global sort state for another round of merging
+	void InitializeMergeRound();
+	//! Completes the cascaded merge sort round.
+	//! Pass true if you wish to use the radix data for further comparisons.
+	void CompleteMergeRound(bool keep_radix_data = false);
+	//! Print the sorted data to the console.
+	void Print();
+
+public:
+	//! The lock for updating the order global state
+	mutex lock;
+	//! The buffer manager
+	BufferManager &buffer_manager;
+
+	//! Sorting and payload layouts
+	const SortLayout sort_layout;
+	const RowLayout payload_layout;
+
+	//! Sorted data
+	vector<unique_ptr<SortedBlock>> sorted_blocks;
+	vector<vector<unique_ptr<SortedBlock>>> sorted_blocks_temp;
+	unique_ptr<SortedBlock> odd_one_out;
+
+	//! Pinned heap data (if sorting in memory)
+	vector<unique_ptr<RowDataBlock>> heap_blocks;
+	vector<BufferHandle> pinned_blocks;
+
+	//! Capacity (number of rows) used to initialize blocks
+	idx_t block_capacity;
+	//! Whether we are doing an external sort
+	bool external;
+
+	//! Progress in merge path stage
+	idx_t pair_idx;
+	idx_t num_pairs;
+	idx_t l_start;
+	idx_t r_start;
+};
+
+struct LocalSortState {
+public:
+	LocalSortState();
+
+	//! Initialize the layouts and RowDataCollections
+	void Initialize(GlobalSortState &global_sort_state, BufferManager &buffer_manager_p);
+	//! Sink one DataChunk into the local sort state
+	void SinkChunk(DataChunk &sort, DataChunk &payload);
+	//! Size of accumulated data in bytes
+	idx_t SizeInBytes() const;
+	//! Sort the data accumulated so far
+	void Sort(GlobalSortState &global_sort_state, bool reorder_heap);
+	//! Concatenate the blocks held by a RowDataCollection into a single block
+	static unique_ptr<RowDataBlock> ConcatenateBlocks(RowDataCollection &row_data);
+
+private:
+	//! Sorts the data in the newly created SortedBlock
+	void SortInMemory();
+	//! Re-order the local state after sorting
+	void ReOrder(GlobalSortState &gstate, bool reorder_heap);
+	//! Re-order a SortedData object after sorting
+	void ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataCollection &heap, GlobalSortState &gstate,
+	             bool reorder_heap);
+
+public:
+	//! Whether this local state has been initialized
+	bool initialized;
+	//! The buffer manager
+	BufferManager *buffer_manager;
+	//! The sorting and payload layouts
+	const SortLayout *sort_layout;
+	const RowLayout *payload_layout;
+	//! Radix/memcmp sortable data
+	unique_ptr<RowDataCollection> radix_sorting_data;
+	//! Variable sized sorting data and accompanying heap
+	unique_ptr<RowDataCollection> blob_sorting_data;
+	unique_ptr<RowDataCollection> blob_sorting_heap;
+	//! Payload data and accompanying heap
+	unique_ptr<RowDataCollection> payload_data;
+	unique_ptr<RowDataCollection> payload_heap;
+	//! Sorted data
+	vector<unique_ptr<SortedBlock>> sorted_blocks;
+
+private:
+	//! Selection vector and addresses for scattering the data to rows
+	const SelectionVector &sel_ptr = *FlatVector::IncrementalSelectionVector();
+	Vector addresses = Vector(LogicalType::POINTER);
+};
+
+struct MergeSorter {
+public:
+	MergeSorter(GlobalSortState &state, BufferManager &buffer_manager);
+
+	//! Finds and merges partitions until the current cascaded merge round is finished
+	void PerformInMergeRound();
+
+private:
+	//! The global sorting state
+	GlobalSortState &state;
+	//! The sorting and payload layouts
+	BufferManager &buffer_manager;
+	const SortLayout &sort_layout;
+
+	//! The left and right reader
+	unique_ptr<SBScanState> left;
+	unique_ptr<SBScanState> right;
+
+	//! Input and output blocks
+	unique_ptr<SortedBlock> left_input;
+	unique_ptr<SortedBlock> right_input;
+	SortedBlock *result;
+
+private:
+	//! Computes the left and right block that will be merged next (Merge Path partition)
+	void GetNextPartition();
+	//! Finds the boundary of the next partition using binary search
+	void GetIntersection(const idx_t diagonal, idx_t &l_idx, idx_t &r_idx);
+	//! Compare values within SortedBlocks using a global index
+	int CompareUsingGlobalIndex(SBScanState &l, SBScanState &r, const idx_t l_idx, const idx_t r_idx);
+
+	//! Finds the next partition and merges it
+	void MergePartition();
+
+	//! Computes how the next 'count' tuples should be merged by setting the 'left_smaller' array
+	void ComputeMerge(const idx_t &count, bool left_smaller[]);
+
+	//! Merges the radix sorting blocks according to the 'left_smaller' array
+	void MergeRadix(const idx_t &count, const bool left_smaller[]);
+	//! Merges SortedData according to the 'left_smaller' array
+	void MergeData(SortedData &result_data, SortedData &l_data, SortedData &r_data, const idx_t &count,
+	               const bool left_smaller[], idx_t next_entry_sizes[], bool reset_indices);
+	//! Merges constant size rows according to the 'left_smaller' array
+	void MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &l_count, data_ptr_t &r_ptr, idx_t &r_entry_idx,
+	               const idx_t &r_count, RowDataBlock &target_block, data_ptr_t &target_ptr, const idx_t &entry_size,
+	               const bool left_smaller[], idx_t &copied, const idx_t &count);
+	//! Flushes constant size rows into the result
+	void FlushRows(data_ptr_t &source_ptr, idx_t &source_entry_idx, const idx_t &source_count,
+	               RowDataBlock &target_block, data_ptr_t &target_ptr, const idx_t &entry_size, idx_t &copied,
+	               const idx_t &count);
+	//! Flushes blob rows and accompanying heap
+	void FlushBlobs(const RowLayout &layout, const idx_t &source_count, data_ptr_t &source_data_ptr,
+	                idx_t &source_entry_idx, data_ptr_t &source_heap_ptr, RowDataBlock &target_data_block,
+	                data_ptr_t &target_data_ptr, RowDataBlock &target_heap_block, BufferHandle &target_heap_handle,
+	                data_ptr_t &target_heap_ptr, idx_t &copied, const idx_t &count);
+};
+
+} // namespace duckdb
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/meta_block_writer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+namespace duckdb {
+class DatabaseInstance;
+
+//! This struct is responsible for writing metadata to disk
+class MetaBlockWriter : public Serializer {
+public:
+	MetaBlockWriter(DatabaseInstance &db, block_id_t initial_block_id = INVALID_BLOCK);
+	~MetaBlockWriter() override;
+
+	DatabaseInstance &db;
 	unique_ptr<Block> block;
 	set<block_id_t> written_blocks;
 	idx_t offset;
@@ -23407,6 +25250,7 @@ protected:
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 class ClientContext;
@@ -23469,6 +25313,10 @@ public:
 
 	//! Insert data into the index. Does not lock the index.
 	virtual bool Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
+	//! Construct an index from sorted chunks of keys.
+	virtual void ConstructAndMerge(IndexLock &lock, PayloadScanner &scanner, Allocator &allocator) = 0;
+	//! Merge other_index into this index.
+	void MergeIndexes(Index *other_index);
 
 	//! Returns true if the index is affected by updates on the specified column ids, and false otherwise
 	bool IndexIsUpdated(const vector<column_t> &column_ids) const;
@@ -23558,224 +25406,36 @@ struct BoundCreateTableInfo {
 	//! Column dependency manager of the table
 	ColumnDependencyManager column_dependency_manager;
 	//! List of constraints on the table
-	vector<unique_ptr<Constraint>> constraints;
-	//! List of bound constraints on the table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	//! Bound default values
-	vector<unique_ptr<Expression>> bound_defaults;
-	//! Dependents of the table (in e.g. default values)
-	unordered_set<CatalogEntry *> dependencies;
-	//! The existing table data on disk (if any)
-	unique_ptr<PersistentTableData> data;
-	//! CREATE TABLE from QUERY
-	unique_ptr<LogicalOperator> query;
-	//! Indexes created by this table <Block_ID, Offset>
-	vector<BlockPointer> indexes;
-
-	//! Serializes a BoundCreateTableInfo to a stand-alone binary blob
-	void Serialize(Serializer &serializer) const;
-	//! Deserializes a blob back into a BoundCreateTableInfo
-	static unique_ptr<BoundCreateTableInfo> Deserialize(Deserializer &source, PlanDeserializationState &state);
-
-	CreateTableInfo &Base() {
-		D_ASSERT(base);
-		return (CreateTableInfo &)*base;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/not_null_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class NotNullConstraint : public Constraint {
-public:
-	DUCKDB_API explicit NotNullConstraint(column_t index);
-	DUCKDB_API ~NotNullConstraint() override;
-
-	//! Column index this constraint pertains to
-	column_t index;
-
-public:
-	DUCKDB_API string ToString() const override;
-
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-
-	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a NotNullConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/data_table.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/column_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ColumnStatistics {
-public:
-	explicit ColumnStatistics(unique_ptr<BaseStatistics> stats_p);
-
-	unique_ptr<BaseStatistics> stats;
-
-public:
-	static shared_ptr<ColumnStatistics> CreateEmptyStats(const LogicalType &type);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer/block_handle.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class BufferHandle;
-class BufferManager;
-class DatabaseInstance;
-class FileBuffer;
-
-enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 };
-
-class BlockHandle {
-	friend struct BufferEvictionNode;
-	friend class BufferHandle;
-	friend class BufferManager;
-
-public:
-	BlockHandle(DatabaseInstance &db, block_id_t block_id);
-	BlockHandle(DatabaseInstance &db, block_id_t block_id, unique_ptr<FileBuffer> buffer, bool can_destroy,
-	            idx_t block_size);
-	~BlockHandle();
-
-	DatabaseInstance &db;
-
-public:
-	block_id_t BlockId() {
-		return block_id;
-	}
-
-	int32_t Readers() const {
-		return readers;
-	}
+	vector<unique_ptr<Constraint>> constraints;
+	//! List of bound constraints on the table
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
+	//! Bound default values
+	vector<unique_ptr<Expression>> bound_defaults;
+	//! Dependents of the table (in e.g. default values)
+	unordered_set<CatalogEntry *> dependencies;
+	//! The existing table data on disk (if any)
+	unique_ptr<PersistentTableData> data;
+	//! CREATE TABLE from QUERY
+	unique_ptr<LogicalOperator> query;
+	//! Indexes created by this table <Block_ID, Offset>
+	vector<BlockPointer> indexes;
 
-	inline bool IsSwizzled() const {
-		return !unswizzled;
-	}
+	//! Serializes a BoundCreateTableInfo to a stand-alone binary blob
+	void Serialize(Serializer &serializer) const;
+	//! Deserializes a blob back into a BoundCreateTableInfo
+	static unique_ptr<BoundCreateTableInfo> Deserialize(Deserializer &source, PlanDeserializationState &state);
 
-	inline void SetSwizzling(const char *unswizzler) {
-		unswizzled = unswizzler;
+	CreateTableInfo &Base() {
+		D_ASSERT(base);
+		return (CreateTableInfo &)*base;
 	}
-
-private:
-	static BufferHandle Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileBuffer> buffer = nullptr);
-	unique_ptr<FileBuffer> UnloadAndTakeBlock();
-	void Unload();
-	bool CanUnload();
-
-	//! The block-level lock
-	mutex lock;
-	//! Whether or not the block is loaded/unloaded
-	BlockState state;
-	//! Amount of concurrent readers
-	atomic<int32_t> readers;
-	//! The block id of the block
-	const block_id_t block_id;
-	//! Pointer to loaded data (if any)
-	unique_ptr<FileBuffer> buffer;
-	//! Internal eviction timestamp
-	atomic<idx_t> eviction_timestamp;
-	//! Whether or not the buffer can be destroyed (only used for temporary buffers)
-	const bool can_destroy;
-	//! The memory usage of the block
-	idx_t memory_usage;
-	//! Does the block contain any memory pointers?
-	const char *unswizzled;
 };
 
 } // namespace duckdb
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/storage/buffer/managed_buffer.hpp
+// duckdb/parser/constraints/not_null_constraint.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23784,150 +25444,85 @@ private:
 
 
 
+namespace duckdb {
 
+class NotNullConstraint : public Constraint {
+public:
+	DUCKDB_API explicit NotNullConstraint(column_t index);
+	DUCKDB_API ~NotNullConstraint() override;
 
-namespace duckdb {
-class DatabaseInstance;
+	//! Column index this constraint pertains to
+	column_t index;
 
-//! Managed buffer is an arbitrarily-sized buffer that is at least of size >= BLOCK_SIZE
-class ManagedBuffer : public FileBuffer {
 public:
-	ManagedBuffer(DatabaseInstance &db, idx_t size, bool can_destroy, block_id_t id);
-	ManagedBuffer(DatabaseInstance &db, FileBuffer &source, bool can_destroy, block_id_t id);
+	DUCKDB_API string ToString() const override;
 
-	DatabaseInstance &db;
-	//! Whether or not the managed buffer can be freely destroyed when unpinned.
-	//! - If can_destroy is true, the buffer can be destroyed when unpinned and hence be unrecoverable. After being
-	//! destroyed, Pin() will return false.
-	//! - If can_destroy is false, the buffer will instead be written to a temporary file on disk when unloaded from
-	//! memory, and read back into memory when Pin() is called.
-	bool can_destroy;
-	//! The internal id of the buffer
-	block_id_t id;
+	DUCKDB_API unique_ptr<Constraint> Copy() const override;
+
+	//! Serialize to a stand-alone binary blob
+	DUCKDB_API void Serialize(FieldWriter &writer) const override;
+	//! Deserializes a NotNullConstraint
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
 };
 
 } // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/data_table.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
 
 
-namespace duckdb {
-class DatabaseInstance;
-class TemporaryDirectoryHandle;
-struct EvictionQueue;
 
-//! The buffer manager is in charge of handling memory management for the database. It hands out memory buffers that can
-//! be used by the database internally.
-class BufferManager {
-	friend class BufferHandle;
-	friend class BlockHandle;
 
-public:
-	BufferManager(DatabaseInstance &db, string temp_directory, idx_t maximum_memory);
-	~BufferManager();
 
-	//! Register a block with the given block id in the base file
-	shared_ptr<BlockHandle> RegisterBlock(block_id_t block_id);
 
-	//! Register an in-memory buffer of arbitrary size, as long as it is >= BLOCK_SIZE. can_destroy signifies whether or
-	//! not the buffer can be destroyed when unpinned, or whether or not it needs to be written to a temporary file so
-	//! it can be reloaded. The resulting buffer will already be allocated, but needs to be pinned in order to be used.
-	shared_ptr<BlockHandle> RegisterMemory(idx_t block_size, bool can_destroy);
 
-	//! Convert an existing in-memory buffer into a persistent disk-backed block
-	shared_ptr<BlockHandle> ConvertToPersistent(BlockManager &block_manager, block_id_t block_id,
-	                                            shared_ptr<BlockHandle> old_block);
 
-	//! Allocate an in-memory buffer with a single pin.
-	//! The allocated memory is released when the buffer handle is destroyed.
-	DUCKDB_API BufferHandle Allocate(idx_t block_size);
 
-	//! Reallocate an in-memory buffer that is pinned.
-	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size);
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/column_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-	BufferHandle Pin(shared_ptr<BlockHandle> &handle);
-	void Unpin(shared_ptr<BlockHandle> &handle);
 
-	void UnregisterBlock(block_id_t block_id, bool can_destroy);
 
-	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted
-	void SetLimit(idx_t limit = (idx_t)-1);
 
-	static BufferManager &GetBufferManager(ClientContext &context);
-	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
 
-	idx_t GetUsedMemory() {
-		return current_memory;
-	}
-	idx_t GetMaxMemory() {
-		return maximum_memory;
-	}
+namespace duckdb {
 
-	const string &GetTemporaryDirectory() {
-		return temp_directory;
-	}
+class ColumnStatistics {
+public:
+	explicit ColumnStatistics(unique_ptr<BaseStatistics> stats_p);
 
-	void SetTemporaryDirectory(string new_dir);
+	unique_ptr<BaseStatistics> stats;
 
-	DUCKDB_API Allocator &GetBufferAllocator();
+public:
+	static shared_ptr<ColumnStatistics> CreateEmptyStats(const LogicalType &type);
+};
 
-private:
-	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
-	//! (i.e. not enough blocks could be evicted)
-	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
-	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
-	bool EvictBlocks(idx_t extra_memory, idx_t memory_limit, unique_ptr<FileBuffer> *buffer = nullptr);
+} // namespace duckdb
 
-	//! Garbage collect eviction queue
-	void PurgeQueue();
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/column_segment.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-	//! Write a temporary buffer to disk
-	void WriteTemporaryBuffer(ManagedBuffer &buffer);
-	//! Read a temporary buffer from disk
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> buffer = nullptr);
-	//! Get the path of the temporary buffer
-	string GetTemporaryPath(block_id_t id);
 
-	void DeleteTemporaryFile(block_id_t id);
 
-	void RequireTemporaryDirectory();
 
-	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
 
-	string InMemoryWarning();
 
-	static data_ptr_t BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size);
-	static void BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
-	static data_ptr_t BufferAllocatorRealloc(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-	                                         idx_t size);
 
-private:
-	//! The database instance
-	DatabaseInstance &db;
-	//! The lock for changing the memory limit
-	mutex limit_lock;
-	//! The current amount of memory that is occupied by the buffer manager (in bytes)
-	atomic<idx_t> current_memory;
-	//! The maximum amount of memory that the buffer manager can keep (in bytes)
-	atomic<idx_t> maximum_memory;
-	//! The directory name where temporary files are stored
-	string temp_directory;
-	//! Lock for creating the temp handle
-	mutex temp_handle_lock;
-	//! Handle for the temporary directory
-	unique_ptr<TemporaryDirectoryHandle> temp_directory_handle;
-	//! The lock for the set of blocks
-	mutex blocks_lock;
-	//! A mapping of block id -> BlockHandle
-	unordered_map<block_id_t, weak_ptr<BlockHandle>> blocks;
-	//! Eviction queue
-	unique_ptr<EvictionQueue> queue;
-	//! The temporary id used for managed buffers
-	atomic<block_id_t> temporary_id;
-	//! Allocator associated with the buffer manager, that passes all allocations through this buffer manager
-	Allocator buffer_allocator;
-};
-} // namespace duckdb
 
 
 
@@ -24369,9 +25964,6 @@ public:
 	void UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
 	                  const vector<column_t> &column_path, DataChunk &updates);
 
-	//! Add an index to the DataTable
-	void AddIndex(unique_ptr<Index> index, const vector<unique_ptr<Expression>> &expressions);
-
 	//! Begin appending structs to this table, obtaining necessary locks, etc
 	void InitializeAppend(Transaction &transaction, TableAppendState &state, idx_t append_count);
 	//! Append a chunk to the table using the AppendState obtained from BeginAppend
@@ -24400,6 +25992,9 @@ public:
 	void SetAsRoot() {
 		this->is_root = true;
 	}
+	bool IsRoot() {
+		return this->is_root;
+	}
 
 	//! Get statistics of a physical column within the table
 	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id);
@@ -24419,6 +26014,11 @@ public:
 	vector<vector<Value>> GetStorageInfo();
 	static bool IsForeignKeyIndex(const vector<idx_t> &fk_keys, Index &index, ForeignKeyType fk_type);
 
+	//! Initializes a special scan that is used to create an index on the table, it keeps locks on the table
+	void InitializeCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids);
+	//! Scans the next chunk for the CREATE INDEX operator
+	bool CreateIndexScan(TableScanState &state, DataChunk &result, TableScanType type);
+
 private:
 	//! Verify the new added constraints against current persistent&local data
 	void VerifyNewConstraint(ClientContext &context, DataTable &parent, const BoundConstraint *constraint);
@@ -24436,10 +26036,6 @@ private:
 	                              idx_t max_row);
 	bool ScanBaseTable(Transaction &transaction, DataChunk &result, TableScanState &state);
 
-	//! The CreateIndexScan is a special scan that is used to create an index on the table, it keeps locks on the table
-	void InitializeCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids);
-	bool ScanCreateIndex(CreateIndexScanState &state, DataChunk &result, TableScanType type);
-
 private:
 	//! Lock for appending entries to the table
 	mutex append_lock;
@@ -27884,6 +29480,53 @@ public:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/alter_function_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Alter Table
+//===--------------------------------------------------------------------===//
+enum class AlterFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
+
+struct AlterFunctionInfo : public AlterInfo {
+	AlterFunctionInfo(AlterFunctionType type, string schema, string name, bool if_exists);
+	virtual ~AlterFunctionInfo() override;
+
+	AlterFunctionType alter_function_type;
+
+public:
+	CatalogType GetCatalogType() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
+};
+
+//===--------------------------------------------------------------------===//
+// AddFunctionOverloadInfo
+//===--------------------------------------------------------------------===//
+struct AddFunctionOverloadInfo : public AlterFunctionInfo {
+	AddFunctionOverloadInfo(string schema, string name, bool if_exists, ScalarFunctionSet new_overloads);
+	~AddFunctionOverloadInfo() override;
+
+	ScalarFunctionSet new_overloads;
+
+public:
+	unique_ptr<AlterInfo> Copy() const override;
+};
+
+} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -28200,6 +29843,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 struct CreateIndexInfo : public CreateInfo {
@@ -28218,7 +29862,12 @@ struct CreateIndexInfo : public CreateInfo {
 	vector<unique_ptr<ParsedExpression>> expressions;
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
 
-	vector<idx_t> column_ids;
+	//! Types used for the CREATE INDEX scan
+	vector<LogicalType> scan_types;
+	//! The names of the columns, used for the CREATE INDEX scan
+	vector<string> names;
+	//! Column IDs needed for index creation
+	vector<column_t> column_ids;
 
 protected:
 	void SerializeInternal(Serializer &serializer) const override;
@@ -28453,14 +30102,16 @@ struct ShowSelectInfo : public ParseInfo {
 namespace duckdb {
 
 struct CreateTypeInfo : public CreateInfo {
-
 	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
 	}
+	CreateTypeInfo(string name_p, LogicalType type_p)
+	    : CreateInfo(CatalogType::TYPE_ENTRY), name(move(name_p)), type(move(type_p)) {
+	}
 
 	//! Name of the Type
 	string name;
 	//! Logical Type
-	LogicalType type; // Shouldn't this be named `logical_type`? (shadows a parent member `type`)
+	LogicalType type;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {