duckdb 0.7.2-dev402.0 → 0.7.2-dev586.0

package/src/duckdb/src/function/aggregate/holistic/quantile.cpp

@@ -795,6 +795,7 @@ AggregateFunction GetTypedDiscreteQuantileListAggregateFunction(const LogicalTyp
 	using STATE = QuantileState<SAVE_TYPE>;
 	using OP = QuantileListOperation<INPUT_TYPE, true>;
 	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
 	return fun;
 }
@@ -851,6 +852,7 @@ AggregateFunction GetTypedContinuousQuantileAggregateFunction(const LogicalType
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = QuantileScalarOperation<false>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
 	return fun;
 }
@@ -904,6 +906,7 @@ AggregateFunction GetTypedContinuousQuantileListAggregateFunction(const LogicalT
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = QuantileListOperation<CHILD_TYPE, false>;
 	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(input_type, result_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
 	return fun;
 }
@@ -1129,6 +1132,7 @@ AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const Logical
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = MedianAbsoluteDeviationOperation<MEDIAN_TYPE>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
 	return fun;
 }
@@ -1198,6 +1202,7 @@ unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunc
 	function.name = "median";
 	function.serialize = QuantileSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1205,6 +1210,7 @@ unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &conte
                                                             vector<unique_ptr<Expression>> &arguments) {
 	function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type);
 	function.name = "mad";
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return nullptr;
 }
 
@@ -1257,6 +1263,7 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimal(ClientContext &context, Agg
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1267,6 +1274,7 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimalList(ClientContext &context,
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1277,6 +1285,7 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimal(ClientContext &context, A
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1287,6 +1296,7 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1316,6 +1326,7 @@ AggregateFunction GetDiscreteQuantileAggregate(const LogicalType &type) {
 	fun.deserialize = QuantileDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1327,6 +1338,7 @@ AggregateFunction GetDiscreteQuantileListAggregate(const LogicalType &type) {
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
 	fun.arguments.push_back(list_of_double);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1337,6 +1349,7 @@ AggregateFunction GetContinuousQuantileAggregate(const LogicalType &type) {
 	fun.deserialize = QuantileDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1348,6 +1361,7 @@ AggregateFunction GetContinuousQuantileListAggregate(const LogicalType &type) {
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
 	fun.arguments.push_back(list_of_double);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1357,6 +1371,7 @@ AggregateFunction GetQuantileDecimalAggregate(const vector<LogicalType> &argumen
 	fun.bind = bind;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -3,6 +3,9 @@
 #include "duckdb/common/types/column_data_collection.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/function/aggregate/distributive_functions.hpp"
 
 namespace duckdb {
 
@@ -363,16 +366,44 @@ struct SortedAggregateFunction {
 	}
 };
 
-unique_ptr<FunctionData> FunctionBinder::BindSortedAggregate(AggregateFunction &bound_function,
-                                                             vector<unique_ptr<Expression>> &children,
-                                                             unique_ptr<FunctionData> bind_info,
-                                                             unique_ptr<BoundOrderModifier> order_bys) {
-
-	auto sorted_bind =
-	    make_unique<SortedAggregateBindData>(context, bound_function, children, std::move(bind_info), *order_bys);
+void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
+                                         const vector<unique_ptr<Expression>> &groups) {
+	if (!expr.order_bys || expr.order_bys->orders.empty() || expr.children.empty()) {
+		// not a sorted aggregate: return
+		return;
+	}
+	if (context.config.enable_optimizer) {
+		// for each ORDER BY - check if it is actually necessary
+		// expressions that are in the groups do not need to be ORDERED BY
+		// `ORDER BY` on a group has no effect, because for each aggregate, the group is unique
+		// similarly, we only need to ORDER BY each aggregate once
+		expression_set_t seen_expressions;
+		for (auto &target : groups) {
+			seen_expressions.insert(target.get());
+		}
+		vector<BoundOrderByNode> new_order_nodes;
+		for (auto &order_node : expr.order_bys->orders) {
+			if (seen_expressions.find(order_node.expression.get()) != seen_expressions.end()) {
+				// we do not need to order by this node
+				continue;
+			}
+			seen_expressions.insert(order_node.expression.get());
+			new_order_nodes.push_back(std::move(order_node));
+		}
+		if (new_order_nodes.empty()) {
+			expr.order_bys.reset();
+			return;
+		}
+		expr.order_bys->orders = std::move(new_order_nodes);
+	}
+	auto &bound_function = expr.function;
+	auto &children = expr.children;
+	auto &order_bys = *expr.order_bys;
+	auto sorted_bind = make_unique<SortedAggregateBindData>(context, bound_function, expr.children,
+	                                                        std::move(expr.bind_info), order_bys);
 
 	// The arguments are the children plus the sort columns.
-	for (auto &order : order_bys->orders) {
+	for (auto &order : order_bys.orders) {
 		children.emplace_back(std::move(order.expression));
 	}
 
@@ -392,9 +423,9 @@ unique_ptr<FunctionData> FunctionBinder::BindSortedAggregate(AggregateFunction &
 	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>, nullptr,
 	    SortedAggregateFunction::Window, SortedAggregateFunction::Serialize, SortedAggregateFunction::Deserialize);
 
-	bound_function = std::move(ordered_aggregate);
-
-	return std::move(sorted_bind);
+	expr.function = std::move(ordered_aggregate);
+	expr.bind_info = std::move(sorted_bind);
+	expr.order_bys.reset();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/function_binder.cpp

@@ -294,8 +294,7 @@ unique_ptr<BoundFunctionExpression> FunctionBinder::BindScalarFunction(ScalarFun
 unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(AggregateFunction bound_function,
                                                                            vector<unique_ptr<Expression>> children,
                                                                            unique_ptr<Expression> filter,
-                                                                           AggregateType aggr_type,
-                                                                           unique_ptr<BoundOrderModifier> order_bys) {
+                                                                           AggregateType aggr_type) {
 	unique_ptr<FunctionData> bind_info;
 	if (bound_function.bind) {
 		bind_info = bound_function.bind(context, bound_function, children);
@@ -306,12 +305,6 @@ unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(Aggre
 	// check if we need to add casts to the children
 	CastToFunctionArguments(bound_function, children);
 
-	// Special case: for ORDER BY aggregates, we wrap the aggregate function in a SortedAggregateFunction
-	// The children are the sort clauses and the binding contains the ordering data.
-	if (order_bys && !order_bys->orders.empty()) {
-		bind_info = BindSortedAggregate(bound_function, children, std::move(bind_info), std::move(order_bys));
-	}
-
 	return make_unique<BoundAggregateExpression>(std::move(bound_function), std::move(children), std::move(filter),
 	                                             std::move(bind_info), aggr_type);
 }

package/src/duckdb/src/function/scalar/date/current.cpp

@@ -35,14 +35,12 @@ static void CurrentTimestampFunction(DataChunk &input, ExpressionState &state, V
 
 void CurrentTimeFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction current_time("get_current_time", {}, LogicalType::TIME, CurrentTimeFunction);
-	;
 	current_time.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
 	set.AddFunction(current_time);
 }
 
 void CurrentDateFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction current_date({}, LogicalType::DATE, CurrentDateFunction);
-	;
 	current_date.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
 	set.AddFunction({"today", "current_date"}, current_date);
 }

package/src/duckdb/src/function/table/arrow.cpp

@@ -101,6 +101,9 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 	} else if (format == "tiM") {
 		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTHS);
 		return LogicalType::INTERVAL;
+	} else if (format == "tin") {
+		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTH_DAY_NANO);
+		return LogicalType::INTERVAL;
 	} else if (format == "+l") {
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);

package/src/duckdb/src/function/table/arrow_conversion.cpp

@@ -316,6 +316,20 @@ void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanLocalS
 	}
 }
 
+void IntervalConversionMonthDayNanos(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
+                                     int64_t nested_offset, idx_t size) {
+	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
+	auto src_ptr = (ArrowInterval *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+	if (nested_offset != -1) {
+		src_ptr = (ArrowInterval *)array.buffers[1] + nested_offset + array.offset;
+	}
+	for (idx_t row = 0; row < size; row++) {
+		tgt_ptr[row].days = src_ptr[row].days;
+		tgt_ptr[row].micros = src_ptr[row].nanoseconds / Interval::NANOS_PER_MICRO;
+		tgt_ptr[row].months = src_ptr[row].months;
+	}
+}
+
 void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                          std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset, ValidityMask *parent_mask) {
@@ -509,6 +523,10 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState
 			IntervalConversionMonths(vector, array, scan_state, nested_offset, size);
 			break;
 		}
+		case ArrowDateTimeType::MONTH_DAY_NANO: {
+			IntervalConversionMonthDayNanos(vector, array, scan_state, nested_offset, size);
+			break;
+		}
 		default:
 			throw std::runtime_error("Unsupported precision for Interval/Duration Type ");
 		}

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev402"
+#define DUCKDB_VERSION "0.7.2-dev586"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "ab9736bed0"
+#define DUCKDB_SOURCE_ID "23ee8b036a"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_function.cpp

@@ -14,12 +14,12 @@ TableFunctionInfo::~TableFunctionInfo() {
 TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
                              table_function_bind_t bind, table_function_init_global_t init_global,
                              table_function_init_local_t init_local)
-    : SimpleNamedParameterFunction(std::move(name), std::move(arguments)), bind(bind), init_global(init_global),
-      init_local(init_local), function(function), in_out_function(nullptr), in_out_function_final(nullptr),
-      statistics(nullptr), dependency(nullptr), cardinality(nullptr), pushdown_complex_filter(nullptr),
-      to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr), get_batch_info(nullptr),
-      serialize(nullptr), deserialize(nullptr), projection_pushdown(false), filter_pushdown(false),
-      filter_prune(false) {
+    : SimpleNamedParameterFunction(std::move(name), std::move(arguments)), bind(bind), bind_replace(nullptr),
+      init_global(init_global), init_local(init_local), function(function), in_out_function(nullptr),
+      in_out_function_final(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
+      pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
+      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
+      filter_pushdown(false), filter_prune(false) {
 }
 
 TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
@@ -28,11 +28,11 @@ TableFunction::TableFunction(const vector<LogicalType> &arguments, table_functio
     : TableFunction(string(), arguments, function, bind, init_global, init_local) {
 }
 TableFunction::TableFunction()
-    : SimpleNamedParameterFunction("", {}), bind(nullptr), init_global(nullptr), init_local(nullptr), function(nullptr),
-      in_out_function(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
-      pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
-      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
-      filter_pushdown(false), filter_prune(false) {
+    : SimpleNamedParameterFunction("", {}), bind(nullptr), bind_replace(nullptr), init_global(nullptr),
+      init_local(nullptr), function(nullptr), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
+      cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
+      get_batch_index(nullptr), get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr),
+      projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
 }
 
 bool TableFunction::Equal(const TableFunction &rhs) const {

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -205,6 +205,9 @@ public:
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
 
+	static bool TypeExists(ClientContext &context, const string &catalog_name, const string &schema,
+	                       const string &name);
+
 	template <class T>
 	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
 	            QueryErrorContext error_context = QueryErrorContext()) {

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp

@@ -35,7 +35,7 @@ public:
 
 	void SetAsRoot() override;
 
-	void CommitAlter(AlterInfo &info);
+	void CommitAlter(string &column_name);
 	void CommitDrop();
 
 	TableFunction GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) override;

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

@@ -25,7 +25,7 @@ struct IndexWriteOperation {
 
 class FieldWriter {
 public:
-	DUCKDB_API FieldWriter(Serializer &serializer);
+	DUCKDB_API explicit FieldWriter(Serializer &serializer);
 	DUCKDB_API ~FieldWriter();
 
 public:
@@ -128,11 +128,11 @@ public:
 		return *buffer;
 	}
 
-private:
 	void AddField() {
 		field_count++;
 	}
 
+private:
 	template <class T>
 	void Write(const T &element) {
 		WriteData((const_data_ptr_t)&element, sizeof(T));
@@ -152,7 +152,7 @@ DUCKDB_API void FieldWriter::Write(const string &val);
 
 class FieldDeserializer : public Deserializer {
 public:
-	FieldDeserializer(Deserializer &root);
+	explicit FieldDeserializer(Deserializer &root);
 
 public:
 	void ReadData(data_ptr_t buffer, idx_t read_size) override;
@@ -163,6 +163,14 @@ public:
 		return root;
 	}
 
+	ClientContext &GetContext() override {
+		return root.GetContext();
+	}
+
+	Catalog *GetCatalog() override {
+		return root.GetCatalog();
+	}
+
 private:
 	Deserializer &root;
 	idx_t remaining_data;
@@ -177,7 +185,7 @@ struct IndexReadOperation {
 
 class FieldReader {
 public:
-	DUCKDB_API FieldReader(Deserializer &source);
+	DUCKDB_API explicit FieldReader(Deserializer &source);
 	DUCKDB_API ~FieldReader();
 
 public:

package/src/duckdb/src/include/duckdb/common/{http_stats.hpp → http_state.hpp}

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/http_stats.hpp
+// duckdb/common/http_state.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -15,7 +15,16 @@
 
 namespace duckdb {
 
-class HTTPStats {
+struct CachedFile {
+	//! Cached Data
+	shared_ptr<char> data;
+	//! Data capacity
+	uint64_t capacity = 0;
+	//! If we finished downloading the file
+	bool finished = false;
+};
+
+class HTTPState {
 public:
 	atomic<idx_t> head_count {0};
 	atomic<idx_t> get_count {0};
@@ -23,6 +32,10 @@ public:
 	atomic<idx_t> post_count {0};
 	atomic<idx_t> total_bytes_received {0};
 	atomic<idx_t> total_bytes_sent {0};
+	//! Mutex to lock when getting the cached file(Parallel Only)
+	mutex cached_files_mutex;
+	//! In case of fully downloading the file, the cached files of this query
+	unordered_map<string, CachedFile> cached_files;
 
 	void Reset() {
 		head_count = 0;
@@ -31,13 +44,14 @@ public:
 		post_count = 0;
 		total_bytes_received = 0;
 		total_bytes_sent = 0;
+		cached_files.clear();
 	}
 
 	//! helper function to get the HTTP
-	static HTTPStats *TryGetStats(FileOpener *opener) {
+	static HTTPState *TryGetState(FileOpener *opener) {
 		auto client_context = FileOpener::TryGetClientContext(opener);
 		if (client_context) {
-			return client_context->client_data->http_stats.get();
+			return client_context->client_data->http_state.get();
 		}
 		return nullptr;
 	}

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

@@ -26,14 +26,16 @@ public:
 	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
 };
 
-class BufferentContextDeserializer : public BufferedDeserializer {
+class BufferedContextDeserializer : public BufferedDeserializer {
 public:
-	BufferentContextDeserializer(ClientContext &context_p, data_ptr_t ptr, idx_t data_size)
+	BufferedContextDeserializer(ClientContext &context_p, data_ptr_t ptr, idx_t data_size)
 	    : BufferedDeserializer(ptr, data_size), context(context_p) {
 	}
 
 public:
 	ClientContext &context;
+
+	ClientContext &GetContext() override;
 };
 
 } // namespace duckdb

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

@@ -14,14 +14,16 @@ namespace duckdb {
 
 class BufferedFileReader : public Deserializer {
 public:
-	BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type = FileLockType::READ_LOCK,
-	                   FileOpener *opener = nullptr);
+	BufferedFileReader(FileSystem &fs, const char *path, ClientContext *context,
+	                   FileLockType lock_type = FileLockType::READ_LOCK, FileOpener *opener = nullptr);
 
 	FileSystem &fs;
 	unique_ptr<data_t[]> data;
 	idx_t offset;
 	idx_t read_data;
 	unique_ptr<FileHandle> handle;
+	ClientContext *context;
+	Catalog *catalog = nullptr;
 
 public:
 	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
@@ -35,6 +37,10 @@ public:
 	void Seek(uint64_t location);
 	uint64_t CurrentOffset();
 
+	ClientContext &GetContext() override;
+
+	Catalog *GetCatalog() override;
+
 private:
 	idx_t file_size;
 	idx_t total_read;

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector.hpp"
@@ -21,6 +22,8 @@ private:
 	uint64_t version = 0L;
 
 public:
+	bool is_query_plan = false;
+
 	virtual ~Serializer() {
 	}
 
@@ -111,6 +114,16 @@ public:
 	//! Reads [read_size] bytes into the buffer
 	virtual void ReadData(data_ptr_t buffer, idx_t read_size) = 0;
 
+	//! Gets the context for the deserializer
+	virtual ClientContext &GetContext() {
+		throw InternalException("This deserializer does not have a client-context");
+	};
+
+	//! Gets the catalog for the deserializer
+	virtual Catalog *GetCatalog() {
+		return nullptr;
+	};
+
 	template <class T>
 	T Read() {
 		T value;

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

@@ -23,6 +23,20 @@ class Value;
 class TypeCatalogEntry;
 class Vector;
 class ClientContext;
+class FieldWriter;
+
+//! Extra Type Info Type
+enum class ExtraTypeInfoType : uint8_t {
+	INVALID_TYPE_INFO = 0,
+	GENERIC_TYPE_INFO = 1,
+	DECIMAL_TYPE_INFO = 2,
+	STRING_TYPE_INFO = 3,
+	LIST_TYPE_INFO = 4,
+	STRUCT_TYPE_INFO = 5,
+	ENUM_TYPE_INFO = 6,
+	USER_TYPE_INFO = 7,
+	AGGREGATE_STATE_TYPE_INFO = 8
+};
 
 struct hugeint_t {
 public:
@@ -297,6 +311,11 @@ struct LogicalType {
 	inline const ExtraTypeInfo *AuxInfo() const {
 		return type_info_.get();
 	}
+
+	inline shared_ptr<ExtraTypeInfo> GetAuxInfoShrPtr() const {
+		return type_info_;
+	}
+
 	inline void CopyAuxInfo(const LogicalType& other) {
 		type_info_ = other.type_info_;
 	}
@@ -324,6 +343,9 @@ 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);
 
@@ -349,6 +371,8 @@ struct LogicalType {
 	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
 	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
 
+	DUCKDB_API static ExtraTypeInfoType GetExtraTypeInfoType(const ExtraTypeInfo &type);
+
 	//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
 	DUCKDB_API bool GetDecimalProperties(uint8_t &width, uint8_t &scale) const;
 
@@ -441,12 +465,14 @@ struct UserType{
 struct EnumType{
 	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
 	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t& key);
-	DUCKDB_API static Vector &GetValuesInsertOrder(const LogicalType &type);
+	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, TypeCatalogEntry* catalog_entry);
 	DUCKDB_API static 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);
 };
 
 struct StructType {

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

@@ -87,6 +87,7 @@ public:
 			// we have data left to read from the file
 			// read directly into the buffer
 			auto bytes_read = file_handle->Read((char *)buffer + result_offset, nr_bytes - result_offset);
+			file_size = file_handle->GetFileSize();
 			read_position += bytes_read;
 			if (reset_enabled) {
 				// if reset caching is enabled, we need to cache the bytes that we have read

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

@@ -88,9 +88,6 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalRecursiveCTE &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCTERef &op);
 
-	unique_ptr<PhysicalOperator> CreateDistinctOn(unique_ptr<PhysicalOperator> child,
-	                                              vector<unique_ptr<Expression>> distinct_targets);
-
 	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

@@ -17,8 +17,9 @@
 
 namespace duckdb {
 
-//! This allows us to use the & operator to check if the type is contained in the set
 enum class AggregateType : uint8_t { NON_DISTINCT = 1, DISTINCT = 2 };
+//! Whether or not the input order influences the result of the aggregate
+enum class AggregateOrderDependent : uint8_t { ORDER_DEPENDENT = 1, NOT_ORDER_DEPENDENT = 2 };
 
 class BoundAggregateExpression;
 
@@ -92,7 +93,7 @@ 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) {
+	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	DUCKDB_API
@@ -107,7 +108,7 @@ 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) {
+	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	DUCKDB_API AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -160,6 +161,8 @@ public:
 
 	aggregate_serialize_t serialize;
 	aggregate_deserialize_t deserialize;
+	//! Whether or not the aggregate is order dependent
+	AggregateOrderDependent order_dependent;
 
 	DUCKDB_API bool operator==(const AggregateFunction &rhs) const {
 		return state_size == rhs.state_size && initialize == rhs.initialize && update == rhs.update &&