duckdb 0.7.2-dev2995.0 → 0.7.2-dev3117.0

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

@@ -32,7 +32,7 @@ public:
 	                       vector<LogicalType> group_types_p, vector<LogicalType> payload_types_p,
 	                       vector<BoundAggregateExpression *> bindings_p);
 
-	idx_t AddChunk(DataChunk &groups, DataChunk &payload, bool do_partition, const vector<idx_t> &filter);
+	idx_t AddChunk(DataChunk &groups, DataChunk &payload, bool do_partition, const unsafe_vector<idx_t> &filter);
 	void Partition();
 	bool IsPartitioned();
 
@@ -51,7 +51,7 @@ private:
 	bool is_partitioned;
 	RadixPartitionInfo &partition_info;
 	vector<SelectionVector> sel_vectors;
-	vector<idx_t> sel_vector_sizes;
+	unsafe_vector<idx_t> sel_vector_sizes;
 	DataChunk group_subset, payload_subset;
 	Vector hashes, hashes_subset;
 	AggregateHTAppendState append_state;
@@ -62,7 +62,7 @@ private:
 
 private:
 	idx_t ListAddChunk(HashTableList &list, DataChunk &groups, Vector &group_hashes, DataChunk &payload,
-	                   const vector<idx_t> &filter);
+	                   const unsafe_vector<idx_t> &filter);
 	//! Returns the HT entry size used for intermediate hash tables
 	HtEntryType GetHTEntrySize();
 };

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

@@ -26,7 +26,7 @@ public:
 
 	GroupingSet &grouping_set;
 	//! The indices specified in the groups_count that do not appear in the grouping_set
-	vector<idx_t> null_groups;
+	unsafe_vector<idx_t> null_groups;
 	const GroupedAggregateData &op;
 
 	vector<LogicalType> group_types;
@@ -42,7 +42,7 @@ public:
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const;
 
 	void Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input, DataChunk &aggregate_input_chunk,
-	          const vector<idx_t> &filter) const;
+	          const unsafe_vector<idx_t> &filter) const;
 	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
 	bool Finalize(ClientContext &context, GlobalSinkState &gstate_p) const;
 

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

@@ -17,6 +17,7 @@ namespace duckdb {
 
 class Binder;
 struct BoundStatement;
+class ColumnDataCollection;
 class ExecutionContext;
 
 struct LocalFunctionData {
@@ -51,6 +52,24 @@ struct GlobalFunctionData {
 	}
 };
 
+struct PreparedBatchData {
+	virtual ~PreparedBatchData() {
+	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
+};
+
+enum class CopyFunctionExecutionMode { REGULAR_COPY_TO_FILE, PARALLEL_COPY_TO_FILE, BATCH_COPY_TO_FILE };
+
 typedef BoundStatement (*copy_to_plan_t)(Binder &binder, CopyStatement &stmt);
 typedef unique_ptr<FunctionData> (*copy_to_bind_t)(ClientContext &context, CopyInfo &info, vector<string> &names,
                                                    vector<LogicalType> &sql_types);
@@ -71,15 +90,21 @@ typedef unique_ptr<FunctionData> (*copy_to_deserialize_t)(ClientContext &context
 typedef unique_ptr<FunctionData> (*copy_from_bind_t)(ClientContext &context, CopyInfo &info,
                                                      vector<string> &expected_names,
                                                      vector<LogicalType> &expected_types);
-typedef bool (*copy_to_is_parallel_t)(ClientContext &context, FunctionData &bind_data);
+typedef CopyFunctionExecutionMode (*copy_to_execution_mode_t)(bool preserve_insertion_order, bool supports_batch_index);
+
+typedef unique_ptr<PreparedBatchData> (*copy_prepare_batch_t)(ClientContext &context, FunctionData &bind_data,
+                                                              GlobalFunctionData &gstate,
+                                                              unique_ptr<ColumnDataCollection> collection);
+typedef void (*copy_flush_batch_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
+                                   PreparedBatchData &batch);
 
 class CopyFunction : public Function {
 public:
 	explicit CopyFunction(string name)
 	    : Function(name), plan(nullptr), copy_to_bind(nullptr), copy_to_initialize_local(nullptr),
 	      copy_to_initialize_global(nullptr), copy_to_sink(nullptr), copy_to_combine(nullptr),
-	      copy_to_finalize(nullptr), parallel(nullptr), serialize(nullptr), deserialize(nullptr),
-	      copy_from_bind(nullptr) {
+	      copy_to_finalize(nullptr), execution_mode(nullptr), prepare_batch(nullptr), flush_batch(nullptr),
+	      serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
 	}
 
 	//! Plan rewrite copy function
@@ -91,7 +116,10 @@ public:
 	copy_to_sink_t copy_to_sink;
 	copy_to_combine_t copy_to_combine;
 	copy_to_finalize_t copy_to_finalize;
-	copy_to_is_parallel_t parallel;
+	copy_to_execution_mode_t execution_mode;
+
+	copy_prepare_batch_t prepare_batch;
+	copy_flush_batch_t flush_batch;
 
 	copy_to_serialize_t serialize;
 	copy_to_deserialize_t deserialize;

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

@@ -54,6 +54,8 @@ struct WriteCSVData : public BaseCSVData {
 	bool is_simple;
 	//! The size of the CSV file (in bytes) that we buffer before we flush it to disk
 	idx_t flush_size = 4096 * 8;
+	//! For each byte whether or not the CSV file requires quotes when containing the byte
+	unique_ptr<bool[]> requires_quotes;
 };
 
 struct ColumnInfo {
@@ -97,8 +99,8 @@ struct ReadCSVData : public BaseCSVData {
 	bool single_threaded = false;
 	//! Reader bind data
 	MultiFileReaderBindData reader_bind;
-	//! If all files are On-Disk file (e.g., not a pipe)
-	bool file_exists = true;
+	//! If any file is a pipe
+	bool is_pipe = false;
 	vector<ColumnInfo> column_info;
 
 	void Initialize(unique_ptr<BufferedCSVReader> &reader) {

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

@@ -84,6 +84,8 @@ struct ExtensionOption {
 struct DBConfigOptions {
 	//! Database file path. May be empty for in-memory mode
 	string database_path;
+	//! Database type. If empty, automatically extracted from `database_path`, where a `type:path` syntax is expected
+	string database_type;
 	//! Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)
 	AccessMode access_mode = AccessMode::AUTOMATIC;
 	//! Checkpoint when WAL reaches this size (default: 16MB)

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

@@ -54,13 +54,11 @@ public:
 
 	DUCKDB_API bool TryGetCurrentSetting(const std::string &key, Value &result);
 
-	//! Get the database extension type from a given path
-	string ExtractDatabaseType(string &path);
 	unique_ptr<AttachedDatabase> CreateAttachedDatabase(AttachInfo &info, const string &type, AccessMode access_mode);
 
 private:
 	void Initialize(const char *path, DBConfig *config);
-	void CreateDatabase(const string &database_type);
+	void CreateMainDatabase();
 
 	void Configure(DBConfig &config);
 

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

@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/database_path_and_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <string>
+#include "duckdb/main/config.hpp"
+
+namespace duckdb {
+
+struct DBPathAndType {
+
+	//! Parse database extension type and rest of path from combined form (type:path)
+	static DBPathAndType Parse(const string &combined_path, const DBConfig &config);
+
+	const string path;
+	const string type;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/relation/setop_relation.hpp

@@ -20,6 +20,7 @@ public:
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
 	SetOperationType setop_type;
+	vector<ColumnDefinition> columns;
 
 public:
 	unique_ptr<QueryNode> GetQueryNode() override;

package/src/duckdb/src/include/duckdb/parser/parsed_data/sample_options.hpp

@@ -17,6 +17,7 @@ namespace duckdb {
 
 enum class SampleMethod : uint8_t { SYSTEM_SAMPLE = 0, BERNOULLI_SAMPLE = 1, RESERVOIR_SAMPLE = 2 };
 
+// **DEPRECATED**: Use EnumUtil directly instead.
 string SampleMethodToString(SampleMethod method);
 
 struct SampleOptions {

package/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp

@@ -59,6 +59,8 @@ protected:
 
 	idx_t TryBindGroup(ParsedExpression &expr, idx_t depth);
 	BindResult BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index);
+
+	bool QualifyColumnAlias(const ColumnRefExpression &colref) override;
 };
 
 } // namespace duckdb

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

@@ -101,6 +101,8 @@ public:
 	static bool ContainsType(const LogicalType &type, LogicalTypeId target);
 	static LogicalType ExchangeType(const LogicalType &type, LogicalTypeId target, LogicalType new_type);
 
+	virtual bool QualifyColumnAlias(const ColumnRefExpression &colref);
+
 	//! Bind the given expresion. Unlike Bind(), this does *not* mute the given ParsedExpression.
 	//! Exposed to be used from sub-binders that aren't subclasses of ExpressionBinder.
 	virtual BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,

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

@@ -35,7 +35,7 @@ public:
 	//! The set of grouping sets (optional).
 	vector<GroupingSet> grouping_sets;
 	//! The list of grouping function calls (optional)
-	vector<vector<idx_t>> grouping_functions;
+	vector<unsafe_vector<idx_t>> grouping_functions;
 	//! Group statistics (optional)
 	vector<unique_ptr<BaseStatistics>> group_stats;
 

package/src/duckdb/src/include/duckdb/planner/query_node/bound_select_node.hpp

@@ -78,7 +78,7 @@ public:
 	vector<unique_ptr<Expression>> aggregates;
 
 	//! GROUPING function calls
-	vector<vector<idx_t>> grouping_functions;
+	vector<unsafe_vector<idx_t>> grouping_functions;
 
 	//! Map from aggregate function to aggregate index (used to eliminate duplicate aggregates)
 	expression_map_t<idx_t> aggregate_map;

package/src/duckdb/src/include/duckdb/verification/deserialized_statement_verifier_v2.hpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/verification/deserialized_statement_verifier_v2.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/verification/statement_verifier.hpp"
+
+namespace duckdb {
+
+//------------------------------------------------------------------------------
+// This is a temporary statement verifier that uses the new de/serialization
+// infrastructure to verify the correctness of the de/serialization process.
+// This verifier will be removed once the new de/serialization infrastructure
+// (FormatDe/Serializer) replaces the old one.
+class DeserializedStatementVerifierV2 : public StatementVerifier {
+public:
+	explicit DeserializedStatementVerifierV2(unique_ptr<SQLStatement> statement_p);
+	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/verification/statement_verifier.hpp

@@ -18,6 +18,7 @@ enum class VerificationType : uint8_t {
 	ORIGINAL,
 	COPIED,
 	DESERIALIZED,
+	DESERIALIZED_V2,
 	PARSED,
 	UNOPTIMIZED,
 	NO_OPERATOR_CACHING,

package/src/duckdb/src/main/client_context.cpp

@@ -495,6 +495,7 @@ unique_ptr<LogicalOperator> ClientContext::ExtractPlan(const string &query) {
 	}
 
 	unique_ptr<LogicalOperator> plan;
+	client_data->http_state = make_uniq<HTTPState>();
 	RunFunctionInTransactionInternal(*lock, [&]() {
 		Planner planner(*this);
 		planner.CreatePlan(std::move(statements[0]));

package/src/duckdb/src/main/client_verify.cpp

@@ -26,6 +26,7 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 	if (config.query_verification_enabled) {
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::COPIED, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED, stmt));
+		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED_V2, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::UNOPTIMIZED, stmt));
 		prepared_statement_verifier = StatementVerifier::Create(VerificationType::PREPARED, stmt);
 #ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE

package/src/duckdb/src/main/database.cpp

@@ -13,9 +13,9 @@
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/storage/magic_bytes.hpp"
 #include "duckdb/storage/object_cache.hpp"
 #include "duckdb/storage/standard_buffer_manager.hpp"
+#include "duckdb/main/database_path_and_type.hpp"
 #include "duckdb/storage/storage_extension.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
@@ -129,22 +129,6 @@ ConnectionManager &ConnectionManager::Get(ClientContext &context) {
 	return ConnectionManager::Get(DatabaseInstance::GetDatabase(context));
 }
 
-string DatabaseInstance::ExtractDatabaseType(string &path) {
-	// first check if there is an existing prefix
-	auto extension = ExtensionHelper::ExtractExtensionPrefixFromPath(path);
-	if (!extension.empty()) {
-		// path is prefixed with an extension - remove it
-		path = StringUtil::Replace(path, extension + ":", "");
-		return extension;
-	}
-	// if there isn't - check the magic bytes of the file (if any)
-	auto file_type = MagicBytes::CheckMagicBytes(config.file_system.get(), path);
-	if (file_type == DataFileType::SQLITE_FILE) {
-		return "sqlite";
-	}
-	return string();
-}
-
 duckdb::unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(AttachInfo &info, const string &type,
                                                                               AccessMode access_mode) {
 	duckdb::unique_ptr<AttachedDatabase> attached_database;
@@ -172,12 +156,12 @@ duckdb::unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(At
 	return attached_database;
 }
 
-void DatabaseInstance::CreateDatabase(const string &database_type) {
+void DatabaseInstance::CreateMainDatabase() {
 	AttachInfo info;
 	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path);
 	info.path = config.options.database_path;
 
-	auto attached_database = CreateAttachedDatabase(info, database_type, config.options.access_mode);
+	auto attached_database = CreateAttachedDatabase(info, config.options.database_type, config.options.access_mode);
 	auto initial_database = attached_database.get();
 	{
 		Connection con(*this);
@@ -235,14 +219,18 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	connection_manager = make_uniq<ConnectionManager>();
 
 	// check if we are opening a standard DuckDB database or an extension database
-	auto database_type = ExtractDatabaseType(config.options.database_path);
+	if (config.options.database_type.empty()) {
+		auto path_and_type = DBPathAndType::Parse(config.options.database_path, config);
+		config.options.database_type = path_and_type.type;
+		config.options.database_path = path_and_type.path;
+	}
 
 	// initialize the system catalog
 	db_manager->InitializeSystemCatalog();
 
-	if (!database_type.empty()) {
+	if (!config.options.database_type.empty()) {
 		// if we are opening an extension database - load the extension
-		ExtensionHelper::LoadExternalExtension(*this, nullptr, database_type);
+		ExtensionHelper::LoadExternalExtension(*this, nullptr, config.options.database_type);
 	}
 
 	if (!config.options.unrecognized_options.empty()) {
@@ -250,7 +238,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	}
 
 	if (!db_manager->HasDefaultDatabase()) {
-		CreateDatabase(database_type);
+		CreateMainDatabase();
 	}
 
 	// only increase thread count after storage init because we get races on catalog otherwise

package/src/duckdb/src/main/database_path_and_type.cpp

@@ -0,0 +1,23 @@
+#include "duckdb/main/database_path_and_type.hpp"
+
+#include "duckdb/main/extension_helper.hpp"
+#include "duckdb/storage/magic_bytes.hpp"
+
+namespace duckdb {
+
+DBPathAndType DBPathAndType::Parse(const string &combined_path, const DBConfig &config) {
+	auto extension = ExtensionHelper::ExtractExtensionPrefixFromPath(combined_path);
+	if (!extension.empty()) {
+		// path is prefixed with an extension - remove it
+		auto path = StringUtil::Replace(combined_path, extension + ":", "");
+		auto type = ExtensionHelper::ApplyExtensionAlias(extension);
+		return {path, type};
+	}
+	// if there isn't - check the magic bytes of the file (if any)
+	auto file_type = MagicBytes::CheckMagicBytes(config.file_system.get(), combined_path);
+	if (file_type == DataFileType::SQLITE_FILE) {
+		return {combined_path, "sqlite"};
+	}
+	return {combined_path, string()};
+}
+} // namespace duckdb

package/src/duckdb/src/main/relation/join_relation.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -51,7 +52,7 @@ const vector<ColumnDefinition> &JoinRelation::Columns() {
 
 string JoinRelation::ToString(idx_t depth) {
 	string str = RenderWhitespace(depth);
-	str += "Join " + JoinTypeToString(join_type);
+	str += "Join " + EnumUtil::ToString(join_type);
 	if (condition) {
 		str += " " + condition->GetName();
 	}

package/src/duckdb/src/main/relation/setop_relation.cpp

@@ -11,8 +11,7 @@ SetOpRelation::SetOpRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> r
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
-	vector<ColumnDefinition> dummy_columns;
-	context.GetContext()->TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> SetOpRelation::GetQueryNode() {
@@ -31,7 +30,7 @@ string SetOpRelation::GetAlias() {
 }
 
 const vector<ColumnDefinition> &SetOpRelation::Columns() {
-	return left->Columns();
+	return this->columns;
 }
 
 string SetOpRelation::ToString(idx_t depth) {

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -4,7 +4,7 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/common/serializer/format_deserializer.hpp"
 

package/src/duckdb/src/parser/parsed_data/sample_options.cpp

@@ -1,13 +1,13 @@
 #include "duckdb/parser/parsed_data/sample_options.hpp"
 #include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
 #include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
+// **DEPRECATED**: Use EnumUtil directly instead.
 string SampleMethodToString(SampleMethod method) {
-	return EnumSerializer::EnumToString(method);
+	return EnumUtil::ToString(method);
 }
 
 void SampleOptions::Serialize(Serializer &serializer) {

package/src/duckdb/src/parser/query_node/select_node.cpp

@@ -97,7 +97,7 @@ string SelectNode::ToString() const {
 		if (sample->is_percentage) {
 			result += "%";
 		}
-		result += " (" + SampleMethodToString(sample->method);
+		result += " (" + EnumUtil::ToString(sample->method);
 		if (sample->seed >= 0) {
 			result += ", " + std::to_string(sample->seed);
 		}

package/src/duckdb/src/parser/result_modifier.cpp

@@ -297,8 +297,8 @@ void LimitPercentModifier::Serialize(FieldWriter &writer) const {
 
 void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteProperty("limit", limit);
-	serializer.WriteProperty("offset", offset);
+	serializer.WriteOptionalProperty("limit", limit);
+	serializer.WriteOptionalProperty("offset", offset);
 }
 
 unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {

package/src/duckdb/src/parser/statement/select_statement.cpp

@@ -46,47 +46,3 @@ string SelectStatement::ToString() const {
 }
 
 } // namespace duckdb
-
-/*
- json_serialize_sql('SELECT BLOB ''\x01\x10'';', format := CAST('t' AS BOOLEAN)){
-"error": false,
-"statements": [
-    {
-        "node": {
-            "type": "SELECT_NODE",
-            "modifiers": [],
-            "cte_map": {
-                "map": []
-            },
-            "select_list": [
-                {
-                    "class": "CONSTANT",
-                    "type": "CONSTANT",
-                    "alias": "",
-                    "value": {
-                        "type": {
-                            "id": "BLOB",
-                            "type_info": null
-                        },
-                        "is_null": false,
-                        "value": "\u0001\u0010"
-                    }
-                }
-            ],
-            "from_table": {
-                "type": "EMPTY",
-                "alias": "",
-                "sample": null
-            },
-            "where_clause": null,
-            "group_expressions": [],
-            "group_sets": [],
-            "aggregate_handling": "STANDARD_HANDLING",
-            "having": null,
-            "sample": null,
-            "qualify": null
-        }
-    }
-]
-}
- */

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -12,15 +12,15 @@ string JoinRef::ToString() const {
 	result = left->ToString() + " ";
 	switch (ref_type) {
 	case JoinRefType::REGULAR:
-		result += JoinTypeToString(type) + " JOIN ";
+		result += EnumUtil::ToString(type) + " JOIN ";
 		break;
 	case JoinRefType::NATURAL:
 		result += "NATURAL ";
-		result += JoinTypeToString(type) + " JOIN ";
+		result += EnumUtil::ToString(type) + " JOIN ";
 		break;
 	case JoinRefType::ASOF:
 		result += "ASOF ";
-		result += JoinTypeToString(type) + " JOIN ";
+		result += EnumUtil::ToString(type) + " JOIN ";
 		break;
 	case JoinRefType::CROSS:
 		result += ", ";

package/src/duckdb/src/parser/tableref.cpp

@@ -30,7 +30,7 @@ string TableRef::BaseToString(string result, const vector<string> &column_name_a
 		result += ")";
 	}
 	if (sample) {
-		result += " TABLESAMPLE " + SampleMethodToString(sample->method);
+		result += " TABLESAMPLE " + EnumUtil::ToString(sample->method);
 		result += "(" + sample->sample_size.ToString() + " " + string(sample->is_percentage ? "PERCENT" : "ROWS") + ")";
 		if (sample->seed >= 0) {
 			result += "REPEATABLE (" + to_string(sample->seed) + ")";

package/src/duckdb/src/parser/transform/expression/transform_function.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/parser/expression/case_expression.hpp"
@@ -305,8 +305,8 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		auto arg_expr = children[0].get();
 		auto &order_by = order_bys->orders[0];
 		if (arg_expr->Equals(order_by.expression.get())) {
-			auto sense = make_uniq<ConstantExpression>(EnumSerializer::EnumToString(order_by.type));
-			auto nulls = make_uniq<ConstantExpression>(EnumSerializer::EnumToString(order_by.null_order));
+			auto sense = make_uniq<ConstantExpression>(EnumUtil::ToChars(order_by.type));
+			auto nulls = make_uniq<ConstantExpression>(EnumUtil::ToChars(order_by.null_order));
 			order_bys = nullptr;
 			auto unordered = make_uniq<FunctionExpression>(catalog, schema, lowercase_name.c_str(), std::move(children),
 			                                               std::move(filter_expr), std::move(order_bys),

package/src/duckdb/src/planner/binder/expression/bind_columnref_expression.cpp

@@ -388,4 +388,10 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t
 	return result;
 }
 
+bool ExpressionBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
+	// Only BaseSelectBinder will have a valid col alias map,
+	// otherwise just return false
+	return false;
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp

@@ -45,7 +45,10 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 				colref = make_uniq<ColumnRefExpression>(function.schema, function.catalog);
 			}
 			auto new_colref = QualifyColumnName(*colref, error);
-			if (error.empty()) {
+			bool is_col = error.empty() ? true : false;
+			bool is_col_alias = QualifyColumnAlias(*colref);
+
+			if (is_col || is_col_alias) {
 				// we can! transform this into a function call on the column
 				// i.e. "x.lower()" becomes "lower(x)"
 				function.children.insert(function.children.begin(), std::move(colref));

package/src/duckdb/src/planner/expression_binder/base_select_binder.cpp

@@ -143,4 +143,11 @@ BindResult BaseSelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_
 	                                                      ColumnBinding(node.group_index, group_index), depth));
 }
 
+bool BaseSelectBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
+	if (!colref.IsQualified()) {
+		return alias_map.find(colref.column_names[0]) != alias_map.end() ? true : false;
+	}
+	return false;
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_aggregate.cpp

@@ -89,7 +89,7 @@ unique_ptr<LogicalOperator> LogicalAggregate::Deserialize(LogicalDeserialization
 	for (idx_t i = 0; i < grouping_sets_size; i++) {
 		grouping_sets.push_back(reader.ReadRequiredSet<idx_t>());
 	}
-	vector<vector<idx_t>> grouping_functions;
+	vector<unsafe_vector<idx_t>> grouping_functions;
 	auto grouping_functions_size = reader.ReadRequired<idx_t>();
 	for (idx_t i = 0; i < grouping_functions_size; i++) {
 		grouping_functions.push_back(reader.ReadRequiredList<idx_t>());