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

package/src/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp

@@ -4,6 +4,8 @@
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 #include <algorithm>
 #include <cmath>
@@ -17,6 +19,8 @@ struct ApproxQuantileState {
 };
 
 struct ApproximateQuantileBindData : public FunctionData {
+	ApproximateQuantileBindData() {
+	}
 	explicit ApproximateQuantileBindData(float quantile_p) : quantiles(1, quantile_p) {
 	}
 
@@ -48,6 +52,18 @@ struct ApproximateQuantileBindData : public FunctionData {
 		return make_uniq<ApproximateQuantileBindData>(std::move(quantiles));
 	}
 
+	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                            const AggregateFunction &function) {
+		auto &bind_data = bind_data_p->Cast<ApproximateQuantileBindData>();
+		serializer.WriteProperty("quantiles", bind_data.quantiles);
+	}
+
+	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
+		auto result = make_uniq<ApproximateQuantileBindData>();
+		deserializer.ReadProperty("quantiles", result->quantiles);
+		return std::move(result);
+	}
+
 	vector<float> quantiles;
 };
 
@@ -192,6 +208,8 @@ unique_ptr<FunctionData> BindApproxQuantileDecimal(ClientContext &context, Aggre
 	function.name = "approx_quantile";
 	function.serialize = ApproximateQuantileBindData::Serialize;
 	function.deserialize = ApproximateQuantileBindData::Deserialize;
+	function.format_serialize = ApproximateQuantileBindData::FormatSerialize;
+	function.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	return bind_data;
 }
 
@@ -200,6 +218,8 @@ AggregateFunction GetApproximateQuantileAggregate(PhysicalType type) {
 	fun.bind = BindApproxQuantile;
 	fun.serialize = ApproximateQuantileBindData::Serialize;
 	fun.deserialize = ApproximateQuantileBindData::Deserialize;
+	fun.format_serialize = ApproximateQuantileBindData::FormatSerialize;
+	fun.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::FLOAT);
 	return fun;
@@ -255,6 +275,8 @@ AggregateFunction GetTypedApproxQuantileListAggregateFunction(const LogicalType
 	auto fun = ApproxQuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
 	fun.serialize = ApproximateQuantileBindData::Serialize;
 	fun.deserialize = ApproximateQuantileBindData::Deserialize;
+	fun.format_serialize = ApproximateQuantileBindData::FormatSerialize;
+	fun.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	return fun;
 }
 
@@ -300,6 +322,8 @@ unique_ptr<FunctionData> BindApproxQuantileDecimalList(ClientContext &context, A
 	function.name = "approx_quantile";
 	function.serialize = ApproximateQuantileBindData::Serialize;
 	function.deserialize = ApproximateQuantileBindData::Deserialize;
+	function.format_serialize = ApproximateQuantileBindData::FormatSerialize;
+	function.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	return bind_data;
 }
 
@@ -308,6 +332,8 @@ AggregateFunction GetApproxQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindApproxQuantile;
 	fun.serialize = ApproximateQuantileBindData::Serialize;
 	fun.deserialize = ApproximateQuantileBindData::Deserialize;
+	fun.format_serialize = ApproximateQuantileBindData::FormatSerialize;
+	fun.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_float = LogicalType::LIST(LogicalType::FLOAT);
 	fun.arguments.push_back(list_of_float);

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

@@ -8,6 +8,8 @@
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/queue.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 #include <algorithm>
 #include <stdlib.h>
@@ -417,6 +419,8 @@ inline Value QuantileAbs(const Value &v) {
 }
 
 struct QuantileBindData : public FunctionData {
+	QuantileBindData() {
+	}
 
 	explicit QuantileBindData(const Value &quantile_p)
 	    : quantiles(1, QuantileAbs(quantile_p)), order(1, 0), desc(quantile_p < 0) {
@@ -456,6 +460,27 @@ struct QuantileBindData : public FunctionData {
 		return desc == other.desc && quantiles == other.quantiles && order == other.order;
 	}
 
+	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                            const AggregateFunction &function) {
+		auto &bind_data = bind_data_p->Cast<QuantileBindData>();
+		serializer.WriteProperty("quantiles", bind_data.quantiles);
+		serializer.WriteProperty("order", bind_data.order);
+		serializer.WriteProperty("desc", bind_data.desc);
+	}
+
+	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
+		auto result = make_uniq<QuantileBindData>();
+		deserializer.ReadProperty("quantiles", result->quantiles);
+		deserializer.ReadProperty("order", result->order);
+		deserializer.ReadProperty("desc", result->desc);
+		return std::move(result);
+	}
+
+	static void FormatSerializeDecimal(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                                   const AggregateFunction &function) {
+		throw SerializationException("FIXME: quantile serialize for decimal");
+	}
+
 	vector<Value> quantiles;
 	vector<idx_t> order;
 	bool desc;
@@ -1189,6 +1214,8 @@ unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunc
 	function.name = "median";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1245,6 +1272,8 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimal(ClientContext &context, Agg
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1256,6 +1285,8 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimalList(ClientContext &context,
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1267,6 +1298,8 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimal(ClientContext &context, A
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1278,6 +1311,8 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1298,6 +1333,8 @@ AggregateFunction GetMedianAggregate(const LogicalType &type) {
 	fun.bind = BindMedian;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	return fun;
 }
 
@@ -1306,6 +1343,8 @@ AggregateFunction GetDiscreteQuantileAggregate(const LogicalType &type) {
 	fun.bind = BindQuantile;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
@@ -1317,6 +1356,8 @@ AggregateFunction GetDiscreteQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindQuantile;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	// 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);
@@ -1329,6 +1370,8 @@ AggregateFunction GetContinuousQuantileAggregate(const LogicalType &type) {
 	fun.bind = BindQuantile;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
@@ -1340,6 +1383,8 @@ AggregateFunction GetContinuousQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindQuantile;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	// 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);
@@ -1353,6 +1398,8 @@ AggregateFunction GetQuantileDecimalAggregate(const vector<LogicalType> &argumen
 	fun.bind = bind;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -4,6 +4,8 @@
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/queue.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 #include <algorithm>
 #include <stdlib.h>
@@ -49,6 +51,8 @@ struct ReservoirQuantileState {
 };
 
 struct ReservoirQuantileBindData : public FunctionData {
+	ReservoirQuantileBindData() {
+	}
 	ReservoirQuantileBindData(double quantile_p, int32_t sample_size_p)
 	    : quantiles(1, quantile_p), sample_size(sample_size_p) {
 	}
@@ -80,6 +84,20 @@ struct ReservoirQuantileBindData : public FunctionData {
 		return make_uniq<ReservoirQuantileBindData>(std::move(quantiles), sample_size);
 	}
 
+	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                            const AggregateFunction &function) {
+		auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
+		serializer.WriteProperty("quantiles", bind_data.quantiles);
+		serializer.WriteProperty("sample_size", bind_data.sample_size);
+	}
+
+	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
+		auto result = make_uniq<ReservoirQuantileBindData>();
+		deserializer.ReadProperty("quantiles", result->quantiles);
+		deserializer.ReadProperty("sample_size", result->sample_size);
+		return std::move(result);
+	}
+
 	vector<double> quantiles;
 	int32_t sample_size;
 };
@@ -355,6 +373,8 @@ unique_ptr<FunctionData> BindReservoirQuantileDecimal(ClientContext &context, Ag
 	function.name = "reservoir_quantile";
 	function.serialize = ReservoirQuantileBindData::Serialize;
 	function.deserialize = ReservoirQuantileBindData::Deserialize;
+	function.format_serialize = ReservoirQuantileBindData::FormatSerialize;
+	function.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	return bind_data;
 }
 
@@ -363,6 +383,8 @@ AggregateFunction GetReservoirQuantileAggregate(PhysicalType type) {
 	fun.bind = BindReservoirQuantile;
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
+	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
+	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	return fun;
@@ -374,6 +396,8 @@ unique_ptr<FunctionData> BindReservoirQuantileDecimalList(ClientContext &context
 	auto bind_data = BindReservoirQuantile(context, function, arguments);
 	function.serialize = ReservoirQuantileBindData::Serialize;
 	function.deserialize = ReservoirQuantileBindData::Deserialize;
+	function.format_serialize = ReservoirQuantileBindData::FormatSerialize;
+	function.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	function.name = "reservoir_quantile";
 	return bind_data;
 }
@@ -383,6 +407,8 @@ AggregateFunction GetReservoirQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindReservoirQuantile;
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
+	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
+	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	// 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);
@@ -411,6 +437,8 @@ static void GetReservoirQuantileDecimalFunction(AggregateFunctionSet &set, const
 	                      BindReservoirQuantileDecimal);
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
+	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
+	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	set.AddFunction(fun);
 
 	fun.arguments.emplace_back(LogicalType::INTEGER);

package/src/duckdb/src/core_functions/scalar/date/strftime.cpp

@@ -94,6 +94,16 @@ ScalarFunctionSet StrfTimeFun::GetFunctions() {
 	return strftime;
 }
 
+StrpTimeFormat::StrpTimeFormat() {
+}
+
+StrpTimeFormat::StrpTimeFormat(const string &format_string) {
+	if (format_string.empty()) {
+		return;
+	}
+	StrTimeFormat::ParseFormatSpecifier(format_string, *this);
+}
+
 struct StrpTimeBindData : public FunctionData {
 	StrpTimeBindData(const StrpTimeFormat &format, const string &format_string)
 	    : formats(1, format), format_strings(1, format_string) {

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -8,6 +8,8 @@
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -28,6 +30,19 @@ public:
 	                                            ScalarFunction &bound_function) {
 		throw NotImplementedException("FIXME: list lambda deserialize");
 	}
+
+	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                            const ScalarFunction &function) {
+		auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
+		serializer.WriteProperty("stype", bind_data.stype);
+		serializer.WriteOptionalProperty("lambda_expr", bind_data.lambda_expr);
+	}
+
+	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, ScalarFunction &function) {
+		auto stype = deserializer.ReadProperty<LogicalType>("stype");
+		auto lambda_expr = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("lambda_expr");
+		return make_uniq<ListLambdaBindData>(stype, std::move(lambda_expr));
+	}
 };
 
 ListLambdaBindData::ListLambdaBindData(const LogicalType &stype_p, unique_ptr<Expression> lambda_expr_p)
@@ -35,12 +50,12 @@ ListLambdaBindData::ListLambdaBindData(const LogicalType &stype_p, unique_ptr<Ex
 }
 
 unique_ptr<FunctionData> ListLambdaBindData::Copy() const {
-	return make_uniq<ListLambdaBindData>(stype, lambda_expr->Copy());
+	return make_uniq<ListLambdaBindData>(stype, lambda_expr ? lambda_expr->Copy() : nullptr);
 }
 
 bool ListLambdaBindData::Equals(const FunctionData &other_p) const {
 	auto &other = other_p.Cast<ListLambdaBindData>();
-	return lambda_expr->Equals(*other.lambda_expr) && stype == other.stype;
+	return Expression::Equals(lambda_expr, other.lambda_expr) && stype == other.stype;
 }
 
 ListLambdaBindData::~ListLambdaBindData() {
@@ -330,7 +345,7 @@ static unique_ptr<FunctionData> ListLambdaBind(ClientContext &context, ScalarFun
 	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
 		bound_function.arguments[0] = LogicalType::SQLNULL;
 		bound_function.return_type = LogicalType::SQLNULL;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+		return make_uniq<ListLambdaBindData>(bound_function.return_type, nullptr);
 	}
 
 	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
@@ -385,6 +400,8 @@ ScalarFunction ListTransformFun::GetFunction() {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
+	fun.format_serialize = ListLambdaBindData::FormatSerialize;
+	fun.format_deserialize = ListLambdaBindData::FormatDeserialize;
 	return fun;
 }
 
@@ -394,6 +411,8 @@ ScalarFunction ListFilterFun::GetFunction() {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
+	fun.format_serialize = ListLambdaBindData::FormatSerialize;
+	fun.format_deserialize = ListLambdaBindData::FormatDeserialize;
 	return fun;
 }
 

package/src/duckdb/src/core_functions/scalar/union/union_tag.cpp

@@ -39,7 +39,7 @@ static unique_ptr<FunctionData> UnionTagBind(ClientContext &context, ScalarFunct
 		FlatVector::GetData<string_t>(varchar_vector)[i] =
 		    str.IsInlined() ? str : StringVector::AddString(varchar_vector, str);
 	}
-	auto enum_type = LogicalType::ENUM("", varchar_vector, member_count);
+	auto enum_type = LogicalType::ENUM(varchar_vector, member_count);
 	bound_function.return_type = enum_type;
 
 	return nullptr;

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -3,7 +3,6 @@
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_any_join.hpp"
 #include "duckdb/planner/operator/logical_create_index.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"
 
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
@@ -29,12 +28,9 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		for (auto &cond : comp_join.conditions) {
 			VisitExpression(&cond.left);
 		}
-		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-			// visit the duplicate eliminated columns on the LHS, if any
-			auto &delim_join = op.Cast<LogicalDelimJoin>();
-			for (auto &expr : delim_join.duplicate_eliminated_columns) {
-				VisitExpression(&expr);
-			}
+		// visit the duplicate eliminated columns on the LHS, if any
+		for (auto &expr : comp_join.duplicate_eliminated_columns) {
+			VisitExpression(&expr);
 		}
 		// then get the bindings of the RHS and resolve the RHS expressions
 		VisitOperator(*comp_join.children[1]);

package/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp

@@ -108,7 +108,7 @@ SinkCombineResultType PhysicalCopyToFile::Combine(ExecutionContext &context, Ope
 		auto partition_key_map = l.part_buffer->GetReverseMap();
 
 		string trimmed_path = file_path;
-		StringUtil::RTrim(trimmed_path, fs.PathSeparator());
+		StringUtil::RTrim(trimmed_path, fs.PathSeparator(trimmed_path));
 
 		for (idx_t i = 0; i < partitions.size(); i++) {
 			string hive_path =

package/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp

@@ -9,16 +9,6 @@
 
 namespace duckdb {
 
-PhysicalTableScan::PhysicalTableScan(vector<LogicalType> types, TableFunction function_p,
-                                     unique_ptr<FunctionData> bind_data_p, vector<column_t> column_ids_p,
-                                     vector<string> names_p, unique_ptr<TableFilterSet> table_filters_p,
-                                     idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::TABLE_SCAN, std::move(types), estimated_cardinality),
-      function(std::move(function_p)), bind_data(std::move(bind_data_p)), column_ids(std::move(column_ids_p)),
-      names(std::move(names_p)), table_filters(std::move(table_filters_p)) {
-	extra_info.file_filters = "";
-}
-
 PhysicalTableScan::PhysicalTableScan(vector<LogicalType> types, TableFunction function_p,
                                      unique_ptr<FunctionData> bind_data_p, vector<LogicalType> returned_types_p,
                                      vector<column_t> column_ids_p, vector<idx_t> projection_ids_p,

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -66,7 +66,8 @@ SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &c
 	const auto &path = info->path;
 
 	if (name.empty()) {
-		name = AttachedDatabase::ExtractDatabaseName(path);
+		auto &fs = FileSystem::GetFileSystem(context.client);
+		name = AttachedDatabase::ExtractDatabaseName(path, fs);
 	}
 	auto &db_manager = DatabaseManager::Get(context.client);
 	auto existing_db = db_manager.GetDatabaseFromPath(context.client, path);

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -74,15 +74,11 @@ SourceResultType PhysicalCreateType::GetData(ExecutionContext &context, DataChun
 	if (IsSink()) {
 		D_ASSERT(info->type == LogicalType::INVALID);
 		auto &g_sink_state = sink_state->Cast<CreateTypeGlobalState>();
-		info->type = LogicalType::ENUM(info->name, g_sink_state.result, g_sink_state.size);
+		info->type = LogicalType::ENUM(g_sink_state.result, g_sink_state.size);
 	}
 
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	auto catalog_entry = catalog.CreateType(context.client, *info);
-	D_ASSERT(catalog_entry->type == CatalogType::TYPE_ENTRY);
-	auto &catalog_type = catalog_entry->Cast<TypeCatalogEntry>();
-	EnumType::SetCatalog(info->type, &catalog_type);
-
+	catalog.CreateType(context.client, *info);
 	return SourceResultType::FINISHED;
 }
 

package/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp

@@ -7,11 +7,10 @@
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/operator/logical_asof_join.hpp"
 
 namespace duckdb {
 
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &op) {
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::PlanAsOfJoin(LogicalComparisonJoin &op) {
 	// now visit the children
 	D_ASSERT(op.children.size() == 2);
 	idx_t lhs_cardinality = op.children[0]->EstimateCardinality(context);

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -237,7 +237,7 @@ static void RewriteJoinCondition(Expression &expr, idx_t offset) {
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { RewriteJoinCondition(child, offset); });
 }
 
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparisonJoin &op) {
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::PlanComparisonJoin(LogicalComparisonJoin &op) {
 	// now visit the children
 	D_ASSERT(op.children.size() == 2);
 	idx_t lhs_cardinality = op.children[0]->EstimateCardinality(context);
@@ -338,4 +338,17 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 	return plan;
 }
 
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparisonJoin &op) {
+	switch (op.type) {
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+		return PlanAsOfJoin(op);
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
+		return PlanComparisonJoin(op);
+	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
+		return PlanDelimJoin(op);
+	default:
+		throw InternalException("Unrecognized operator type for LogicalComparisonJoin");
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_create_index.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/execution/operator/filter/physical_filter.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
 #include "duckdb/execution/operator/schema/physical_create_index.hpp"
 #include "duckdb/execution/operator/order/physical_order.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/planner/operator/logical_create_index.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/table_filter.hpp"
@@ -14,11 +13,10 @@
 namespace duckdb {
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateIndex &op) {
-
 	// generate a physical plan for the parallel index creation which consists of the following operators
 	// table scan - projection (for expression execution) - filter (NOT NULL) - order - create index
-
-	D_ASSERT(op.children.empty());
+	D_ASSERT(op.children.size() == 1);
+	auto table_scan = CreatePlan(*op.children[0]);
 
 	// validate that all expressions contain valid scalar functions
 	// e.g. get_current_timestamp(), random(), and sequence values are not allowed as ART keys
@@ -32,19 +30,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	}
 
 	// table scan operator for index key columns and row IDs
-
-	unique_ptr<TableFilterSet> table_filters;
-	op.info->column_ids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
-
-	auto &bind_data = op.bind_data->Cast<TableScanBindData>();
-	bind_data.is_create_index = true;
-
-	auto table_scan =
-	    make_uniq<PhysicalTableScan>(op.info->scan_types, op.function, std::move(op.bind_data), op.info->column_ids,
-	                                 op.info->names, std::move(table_filters), op.estimated_cardinality);
-
 	dependencies.AddDependency(op.table);
-	op.info->column_ids.pop_back();
 
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->column_ids.size());

package/src/duckdb/src/execution/physical_plan/plan_delim_join.cpp

@@ -1,10 +1,7 @@
-#include "duckdb/execution/aggregate_hashtable.hpp"
 #include "duckdb/execution/operator/join/physical_delim_join.hpp"
 #include "duckdb/execution/operator/join/physical_hash_join.hpp"
 #include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
 
@@ -19,9 +16,9 @@ static void GatherDelimScans(const PhysicalOperator &op, vector<const_reference<
 	}
 }
 
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimJoin &op) {
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::PlanDelimJoin(LogicalComparisonJoin &op) {
 	// first create the underlying join
-	auto plan = CreatePlan(op.Cast<LogicalComparisonJoin>());
+	auto plan = PlanComparisonJoin(op);
 	// this should create a join, not a cross product
 	D_ASSERT(plan && plan->type != PhysicalOperatorType::CROSS_PRODUCT);
 	// duplicate eliminated join

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -113,12 +113,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 		plan = CreatePlan(op.Cast<LogicalAnyJoin>());
 		break;
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		plan = CreatePlan(op.Cast<LogicalDelimJoin>());
-		break;
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		plan = CreatePlan(op.Cast<LogicalAsOfJoin>());
-		break;
+	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		plan = CreatePlan(op.Cast<LogicalComparisonJoin>());
 		break;

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -218,22 +218,11 @@ AggregateFunction CountFun::GetFunction() {
 	return fun;
 }
 
-static void CountStarSerialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
-}
-
-static unique_ptr<FunctionData> CountStarDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                     AggregateFunction &function) {
-	return nullptr;
-}
-
 AggregateFunction CountStarFun::GetFunction() {
 	auto fun = AggregateFunction::NullaryAggregate<int64_t, int64_t, CountStarFunction>(LogicalType::BIGINT);
 	fun.name = "count_star";
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.window = CountStarFunction::Window<int64_t>;
-	// TODO is there a better way to set those?
-	fun.serialize = CountStarSerialize;
-	fun.deserialize = CountStarDeserialize;
 	return fun;
 }
 

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

@@ -516,14 +516,6 @@ struct SortedAggregateFunction {
 
 		result.Verify(count);
 	}
-
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
-		throw NotImplementedException("FIXME: serialize sorted aggregate not supported");
-	}
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            AggregateFunction &function) {
-		throw NotImplementedException("FIXME: deserialize sorted aggregate not supported");
-	}
 };
 
 void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
@@ -582,7 +574,7 @@ void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateE
 	    AggregateFunction::StateCombine<SortedAggregateState, SortedAggregateFunction>,
 	    SortedAggregateFunction::Finalize, bound_function.null_handling, SortedAggregateFunction::SimpleUpdate, nullptr,
 	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>, nullptr,
-	    SortedAggregateFunction::Window, SortedAggregateFunction::Serialize, SortedAggregateFunction::Deserialize);
+	    SortedAggregateFunction::Window);
 
 	expr.function = std::move(ordered_aggregate);
 	expr.bind_info = std::move(sorted_bind);