duckdb 0.8.2-dev2090.0 → 0.8.2-dev2208.0

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

@@ -22,8 +22,6 @@ private:
 	uint64_t version = 0L;
 
 public:
-	bool is_query_plan = false;
-
 	virtual ~Serializer() {
 	}
 
@@ -119,11 +117,6 @@ public:
 		throw InternalException("This deserializer does not have a client-context");
 	};
 
-	//! Gets the catalog for the deserializer
-	virtual optional_ptr<Catalog> GetCatalog() {
-		return nullptr;
-	};
-
 	template <class T>
 	T Read() {
 		T value;

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

@@ -26,7 +26,7 @@ struct timestamp_t { // NOLINT
 	int64_t value;
 
 	timestamp_t() = default;
-	explicit inline timestamp_t(int64_t value_p) : value(value_p) {
+	explicit inline constexpr timestamp_t(int64_t value_p) : value(value_p) {
 	}
 	inline timestamp_t &operator=(int64_t value_p) {
 		value = value_p;
@@ -67,21 +67,25 @@ struct timestamp_t { // NOLINT
 	timestamp_t &operator-=(const int64_t &delta);
 
 	// special values
-	static timestamp_t infinity() { // NOLINT
+	static constexpr timestamp_t infinity() { // NOLINT
 		return timestamp_t(NumericLimits<int64_t>::Maximum());
-	}                                // NOLINT
-	static timestamp_t ninfinity() { // NOLINT
+	}                                          // NOLINT
+	static constexpr timestamp_t ninfinity() { // NOLINT
 		return timestamp_t(-NumericLimits<int64_t>::Maximum());
-	}                                   // NOLINT
-	static inline timestamp_t epoch() { // NOLINT
+	}                                             // NOLINT
+	static constexpr inline timestamp_t epoch() { // NOLINT
 		return timestamp_t(0);
 	} // NOLINT
 };
 
-struct timestamp_tz_t : public timestamp_t {};  // NOLINT
-struct timestamp_ns_t : public timestamp_t {};  // NOLINT
-struct timestamp_ms_t : public timestamp_t {};  // NOLINT
-struct timestamp_sec_t : public timestamp_t {}; // NOLINT
+struct timestamp_tz_t : public timestamp_t { // NOLINT
+};
+struct timestamp_ns_t : public timestamp_t { // NOLINT
+};
+struct timestamp_ms_t : public timestamp_t { // NOLINT
+};
+struct timestamp_sec_t : public timestamp_t { // NOLINT
+};
 
 enum class TimestampCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_NON_UTC_TIMEZONE };
 

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

@@ -286,8 +286,6 @@ struct LogicalType {
 	//! Serializes a LogicalType to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 
-	DUCKDB_API void SerializeEnumType(Serializer &serializer) const;
-
 	//! Deserializes a blob back into an LogicalType
 	DUCKDB_API static LogicalType Deserialize(Deserializer &source);
 
@@ -373,9 +371,10 @@ public:
 	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT
 	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type);    // NOLINT
 	DUCKDB_API static LogicalType MAP(const LogicalType &child);				// NOLINT
-	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT
 	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value); // NOLINT
 	DUCKDB_API static LogicalType UNION( child_list_t<LogicalType> members);     // NOLINT
+	DUCKDB_API static LogicalType ENUM(Vector &ordered_data, idx_t size); // NOLINT
+	// DEPRECATED - provided for backwards compatibility
 	DUCKDB_API static LogicalType ENUM(const string &enum_name, Vector &ordered_data, idx_t size); // NOLINT
 	DUCKDB_API static LogicalType USER(const string &user_type_name); // NOLINT
 	//! A list of all NUMERIC types (integral and floating point types)
@@ -400,21 +399,17 @@ struct ListType {
 	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type);
 };
 
-struct UserType{
+struct UserType {
 	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
 };
 
-struct EnumType{
-	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
+struct EnumType {
 	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t& key);
 	DUCKDB_API static const Vector &GetValuesInsertOrder(const LogicalType &type);
 	DUCKDB_API static idx_t GetSize(const LogicalType &type);
 	DUCKDB_API static const string GetValue(const Value &val);
-	DUCKDB_API static void SetCatalog(LogicalType &type, optional_ptr<TypeCatalogEntry> catalog_entry);
-	DUCKDB_API static optional_ptr<TypeCatalogEntry> GetCatalog(const LogicalType &type);
-	DUCKDB_API static string GetSchemaName(const LogicalType &type);
 	DUCKDB_API static PhysicalType GetPhysicalType(const LogicalType &type);
-	DUCKDB_API static void Serialize(FieldWriter& writer, const ExtraTypeInfo& type_info, bool serialize_internals);
+	DUCKDB_API static string_t GetString(const LogicalType &type, idx_t pos);
 };
 
 struct StructType {

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

@@ -68,6 +68,8 @@ public:
 
 	void SetDisabledFileSystems(const vector<string> &names) override;
 
+	string PathSeparator(const string &path) override;
+
 private:
 	FileSystem &FindFileSystem(const string &path);
 	FileSystem &FindFileSystemInternal(const string &path);

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

@@ -147,6 +147,8 @@ struct BufferedCSVReaderOptions {
 
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static BufferedCSVReaderOptions FormatDeserialize(FormatDeserializer &deserializer);
 
 	void SetCompression(const string &compression);
 	void SetHeader(bool has_header);

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp

@@ -22,10 +22,6 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::TABLE_SCAN;
 
 public:
-	//! Regular Table Scan
-	PhysicalTableScan(vector<LogicalType> types, TableFunction function, unique_ptr<FunctionData> bind_data,
-	                  vector<column_t> column_ids, vector<string> names, unique_ptr<TableFilterSet> table_filters,
-	                  idx_t estimated_cardinality);
 	//! Table scan that immediately projects out filter columns that are unused in the remainder of the query plan
 	PhysicalTableScan(vector<LogicalType> types, TableFunction function, unique_ptr<FunctionData> bind_data,
 	                  vector<LogicalType> returned_types, vector<column_t> column_ids, vector<idx_t> projection_ids,

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

@@ -50,7 +50,6 @@ protected:
 
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalAggregate &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalAnyJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalAsOfJoin &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalColumnDataGet &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalComparisonJoin &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreate &op);
@@ -59,7 +58,6 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCrossProduct &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelete &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimJoin &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDistinct &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDummyScan &expr);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalEmptyResult &op);
@@ -93,6 +91,9 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCTERef &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalPivot &op);
 
+	unique_ptr<PhysicalOperator> PlanAsOfJoin(LogicalComparisonJoin &op);
+	unique_ptr<PhysicalOperator> PlanComparisonJoin(LogicalComparisonJoin &op);
+	unique_ptr<PhysicalOperator> PlanDelimJoin(LogicalComparisonJoin &op);
 	unique_ptr<PhysicalOperator> ExtractAggregateExpressions(unique_ptr<PhysicalOperator> child,
 	                                                         vector<unique_ptr<Expression>> &expressions,
 	                                                         vector<unique_ptr<Expression>> &groups);

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

@@ -52,6 +52,11 @@ typedef void (*aggregate_serialize_t)(FieldWriter &writer, const FunctionData *b
 typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
                                                             AggregateFunction &function);
 
+typedef void (*aggregate_format_serialize_t)(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                             const AggregateFunction &function);
+typedef unique_ptr<FunctionData> (*aggregate_format_deserialize_t)(FormatDeserializer &deserializer,
+                                                                   AggregateFunction &function);
+
 class AggregateFunction : public BaseScalarFunction {
 public:
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -66,7 +71,8 @@ public:
 	                         LogicalType(LogicalTypeId::INVALID), null_handling),
 	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
 	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics),
-	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), format_serialize(nullptr), format_deserialize(nullptr),
+	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -80,7 +86,8 @@ public:
 	                         LogicalType(LogicalTypeId::INVALID)),
 	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
 	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics),
-	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), format_serialize(nullptr), format_deserialize(nullptr),
+	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
@@ -131,6 +138,8 @@ public:
 
 	aggregate_serialize_t serialize;
 	aggregate_deserialize_t deserialize;
+	aggregate_format_serialize_t format_serialize;
+	aggregate_format_deserialize_t format_deserialize;
 	//! Whether or not the aggregate is order dependent
 	AggregateOrderDependent order_dependent;
 

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

@@ -11,6 +11,8 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -97,6 +99,85 @@ public:
 		function.return_type = return_type;
 		return function;
 	}
+
+	template <class FUNC>
+	static void FormatSerialize(FormatSerializer &serializer, const FUNC &function,
+	                            optional_ptr<FunctionData> bind_info) {
+		D_ASSERT(!function.name.empty());
+		serializer.WriteProperty("name", function.name);
+		serializer.WriteProperty("arguments", function.arguments);
+		serializer.WriteProperty("original_arguments", function.original_arguments);
+		bool has_serialize = function.format_serialize;
+		serializer.WriteProperty("has_serialize", has_serialize);
+		if (has_serialize) {
+			serializer.BeginObject("function_data");
+			function.format_serialize(serializer, bind_info, function);
+			serializer.EndObject();
+			D_ASSERT(function.format_deserialize);
+		}
+	}
+
+	template <class FUNC, class CATALOG_ENTRY>
+	static FUNC DeserializeFunction(ClientContext &context, CatalogType catalog_type, const string &name,
+	                                vector<LogicalType> arguments, vector<LogicalType> original_arguments) {
+		auto &func_catalog = Catalog::GetEntry(context, catalog_type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
+		if (func_catalog.type != catalog_type) {
+			throw InternalException("DeserializeFunction - cant find catalog entry for function %s", name);
+		}
+		auto &functions = func_catalog.Cast<CATALOG_ENTRY>();
+		auto function = functions.functions.GetFunctionByArguments(
+		    context, original_arguments.empty() ? arguments : original_arguments);
+		function.arguments = std::move(arguments);
+		function.original_arguments = std::move(original_arguments);
+		return function;
+	}
+
+	template <class FUNC, class CATALOG_ENTRY>
+	static pair<FUNC, bool> FormatDeserializeBase(FormatDeserializer &deserializer, CatalogType catalog_type) {
+		auto &context = deserializer.Get<ClientContext &>();
+		auto name = deserializer.ReadProperty<string>("name");
+		auto arguments = deserializer.ReadProperty<vector<LogicalType>>("arguments");
+		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>("original_arguments");
+		auto function = DeserializeFunction<FUNC, CATALOG_ENTRY>(context, catalog_type, name, std::move(arguments),
+		                                                         std::move(original_arguments));
+		auto has_serialize = deserializer.ReadProperty<bool>("has_serialize");
+		return make_pair(std::move(function), has_serialize);
+	}
+
+	template <class FUNC>
+	static unique_ptr<FunctionData> FunctionDeserialize(FormatDeserializer &deserializer, FUNC &function) {
+		if (!function.format_deserialize) {
+			throw SerializationException("Function requires deserialization but no deserialization function for %s",
+			                             function.name);
+		}
+		deserializer.BeginObject("function_data");
+		auto result = function.format_deserialize(deserializer, function);
+		deserializer.EndObject();
+		return result;
+	}
+
+	template <class FUNC, class CATALOG_ENTRY>
+	static pair<FUNC, unique_ptr<FunctionData>> FormatDeserialize(FormatDeserializer &deserializer,
+	                                                              CatalogType catalog_type,
+	                                                              vector<unique_ptr<Expression>> &children) {
+		auto &context = deserializer.Get<ClientContext &>();
+		auto entry = FormatDeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
+		auto &function = entry.first;
+		auto has_serialize = entry.second;
+
+		unique_ptr<FunctionData> bind_data;
+		if (has_serialize) {
+			bind_data = FunctionDeserialize<FUNC>(deserializer, function);
+		} else if (function.bind) {
+			try {
+				bind_data = function.bind(context, function, children);
+			} catch (Exception &ex) {
+				// FIXME
+				throw SerializationException("Error during bind of function in deserialization: %s", ex.what());
+			}
+		}
+		return make_pair(std::move(function), std::move(bind_data));
+	}
 };
 
 } // namespace duckdb

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

@@ -121,6 +121,8 @@ protected:
 
 struct StrpTimeFormat : public StrTimeFormat {
 public:
+	StrpTimeFormat();
+
 	//! Type-safe parsing argument
 	struct ParseResult {
 		int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
@@ -148,12 +150,18 @@ public:
 	date_t ParseDate(string_t str);
 	timestamp_t ParseTimestamp(string_t str);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static StrpTimeFormat FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	static string FormatStrpTimeError(const string &input, idx_t position);
 	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
 	int NumericSpecifierWidth(StrTimeSpecifier specifier);
 	int32_t TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
 	                           idx_t collection_count);
+
+private:
+	explicit StrpTimeFormat(const string &format_string);
 };
 
 } // namespace duckdb

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

@@ -69,6 +69,11 @@ typedef void (*function_serialize_t)(FieldWriter &writer, const FunctionData *bi
 typedef unique_ptr<FunctionData> (*function_deserialize_t)(PlanDeserializationState &state, FieldReader &reader,
                                                            ScalarFunction &function);
 
+typedef void (*function_format_serialize_t)(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                            const ScalarFunction &function);
+typedef unique_ptr<FunctionData> (*function_format_deserialize_t)(FormatDeserializer &deserializer,
+                                                                  ScalarFunction &function);
+
 class ScalarFunction : public BaseScalarFunction {
 public:
 	DUCKDB_API ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
@@ -100,14 +105,14 @@ public:
 	function_serialize_t serialize;
 	function_deserialize_t deserialize;
 
+	function_format_serialize_t format_serialize;
+	function_format_deserialize_t format_deserialize;
+
 	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
 	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;
 
 	DUCKDB_API bool Equal(const ScalarFunction &rhs) const;
 
-private:
-	bool CompareScalarFunctionT(const scalar_function_t &other) const;
-
 public:
 	DUCKDB_API static void NopFunction(DataChunk &input, ExpressionState &state, Vector &result);
 

package/src/duckdb/src/include/duckdb/function/table/read_csv.hpp

@@ -76,6 +76,10 @@ struct ColumnInfo {
 		info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 		return info;
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static ColumnInfo FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<std::string> names;
 	vector<LogicalType> types;
 };
@@ -105,6 +109,9 @@ struct ReadCSVData : public BaseCSVData {
 		this->initial_reader = std::move(reader);
 	}
 	void FinalizeRead(ClientContext &context);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ReadCSVData> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 struct CSVCopyFunction {

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

@@ -207,6 +207,12 @@ typedef void (*table_function_serialize_t)(FieldWriter &writer, const FunctionDa
 typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
                                                                  TableFunction &function);
 
+typedef void (*table_function_format_serialize_t)(FormatSerializer &serializer,
+                                                  const optional_ptr<FunctionData> bind_data,
+                                                  const TableFunction &function);
+typedef unique_ptr<FunctionData> (*table_function_format_deserialize_t)(FormatDeserializer &deserializer,
+                                                                        TableFunction &function);
+
 class TableFunction : public SimpleNamedParameterFunction {
 public:
 	DUCKDB_API
@@ -265,6 +271,8 @@ public:
 
 	table_function_serialize_t serialize;
 	table_function_deserialize_t deserialize;
+	table_function_format_serialize_t format_serialize;
+	table_function_format_deserialize_t format_deserialize;
 	bool verify_serialization = true;
 
 	//! Whether or not the table function supports projection pushdown. If not supported a projection will be added

package/src/duckdb/src/include/duckdb/main/attached_database.hpp

@@ -60,7 +60,7 @@ public:
 	bool IsInitialDatabase() const;
 	void SetInitialDatabase();
 
-	static string ExtractDatabaseName(const string &dbpath);
+	static string ExtractDatabaseName(const string &dbpath, FileSystem &fs);
 
 private:
 	DatabaseInstance &db;

package/src/duckdb/src/include/duckdb/optimizer/deliminator.hpp

@@ -27,9 +27,9 @@ private:
 	void FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCandidate> &candidates);
 	void FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate);
 	//! Remove joins with a DelimGet
-	bool RemoveJoinWithDelimGet(LogicalDelimJoin &delim_join, const idx_t delim_get_count,
+	bool RemoveJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
 	                            unique_ptr<LogicalOperator> &join, bool &all_equality_conditions);
-	bool RemoveInequalityJoinWithDelimGet(LogicalDelimJoin &delim_join, const idx_t delim_get_count,
+	bool RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
 	                                      unique_ptr<LogicalOperator> &join,
 	                                      const vector<ReplacementBinding> &replacement_bindings);
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_aggregate_expression.hpp

@@ -57,5 +57,8 @@ public:
 	unique_ptr<Expression> Copy() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp

@@ -46,5 +46,9 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp

@@ -67,5 +67,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/filter/conjunction_filter.hpp

@@ -45,6 +45,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class ConjunctionAndFilter : public ConjunctionFilter {
@@ -60,6 +62,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp

@@ -32,6 +32,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/filter/null_filter.hpp

@@ -24,6 +24,8 @@ public:
 	string ToString(const string &column_name) override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class IsNotNullFilter : public TableFilter {
@@ -38,6 +40,8 @@ public:
 	string ToString(const string &column_name) override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/logical_tokens.hpp

@@ -14,7 +14,6 @@ class LogicalOperator;
 
 class LogicalAggregate;
 class LogicalAnyJoin;
-class LogicalAsOfJoin;
 class LogicalColumnDataGet;
 class LogicalComparisonJoin;
 class LogicalCopyToFile;
@@ -26,7 +25,6 @@ class LogicalCrossProduct;
 class LogicalCTERef;
 class LogicalDelete;
 class LogicalDelimGet;
-class LogicalDelimJoin;
 class LogicalDistinct;
 class LogicalDummyScan;
 class LogicalEmptyResult;

package/src/duckdb/src/include/duckdb/planner/operator/list.hpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_aggregate.hpp"
 #include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_asof_join.hpp"
 #include "duckdb/planner/operator/logical_column_data_get.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_copy_to_file.hpp"
@@ -11,7 +10,6 @@
 #include "duckdb/planner/operator/logical_cteref.hpp"
 #include "duckdb/planner/operator/logical_delete.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
 #include "duckdb/planner/operator/logical_empty_result.hpp"
@@ -19,6 +17,7 @@
 #include "duckdb/planner/operator/logical_explain.hpp"
 #include "duckdb/planner/operator/logical_export.hpp"
 #include "duckdb/planner/operator/logical_expression_get.hpp"
+#include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"

package/src/duckdb/src/include/duckdb/planner/operator/logical_comparison_join.hpp

@@ -15,7 +15,6 @@
 #include "duckdb/planner/operator/logical_join.hpp"
 
 namespace duckdb {
-class LogicalDelimJoin;
 
 //! LogicalComparisonJoin represents a join that involves comparisons between the LHS and RHS
 class LogicalComparisonJoin : public LogicalJoin {
@@ -30,6 +29,8 @@ public:
 	vector<JoinCondition> conditions;
 	//! Used for duplicate-eliminated MARK joins
 	vector<LogicalType> mark_types;
+	//! The set of columns that will be duplicate eliminated from the LHS and pushed into the RHS
+	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
 
 public:
 	string ParamsToString() const override;
@@ -41,9 +42,6 @@ public:
 	void FormatSerialize(FormatSerializer &serializer) const override;
 	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 
-	//! Turn a delim join into a regular comparison join (after all required delim scans have been pruned)
-	static unique_ptr<LogicalOperator> FromDelimJoin(LogicalDelimJoin &join);
-
 public:
 	static unique_ptr<LogicalOperator> CreateJoin(ClientContext &context, JoinType type, JoinRefType ref_type,
 	                                              unique_ptr<LogicalOperator> left_child,

package/src/duckdb/src/include/duckdb/planner/operator/logical_copy_to_file.hpp

@@ -45,6 +45,8 @@ public:
 	bool SupportSerialization() const override {
 		return false;
 	}
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_create_index.hpp

@@ -19,19 +19,14 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_INDEX;
 
 public:
-	LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
-	                   vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,
-	                   TableFunction function_p);
+	LogicalCreateIndex(unique_ptr<CreateIndexInfo> info_p, vector<unique_ptr<Expression>> expressions_p,
+	                   TableCatalogEntry &table_p);
 
-	//! The bind data of the function
-	unique_ptr<FunctionData> bind_data;
 	// Info for index creation
 	unique_ptr<CreateIndexInfo> info;
 
 	//! The table to create the index for
 	TableCatalogEntry &table;
-	//! The function that is called
-	TableFunction function;
 
 	//! Unbound expressions to be used in the optimizer
 	vector<unique_ptr<Expression>> unbound_expressions;
@@ -40,7 +35,15 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalCreateIndex(ClientContext &context, unique_ptr<CreateInfo> info, vector<unique_ptr<Expression>> expressions);
+
+	TableCatalogEntry &BindTable(ClientContext &context, CreateIndexInfo &info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_extension_operator.hpp

@@ -26,6 +26,11 @@ public:
 
 	static unique_ptr<LogicalExtensionOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	virtual unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) = 0;
+
+	virtual string GetExtensionName() const;
 };
 } // namespace duckdb