duckdb 0.7.1 → 0.7.2-dev1034.0

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

@@ -11,9 +11,36 @@
 #include "duckdb/function/function_set.hpp"
 #include "re2/re2.h"
 #include "duckdb/function/built_in_functions.hpp"
+#include "re2/stringpiece.h"
 
 namespace duckdb {
 
+namespace regexp_util {
+
+bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string);
+void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr);
+void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace = nullptr);
+
+inline duckdb_re2::StringPiece CreateStringPiece(const string_t &input) {
+	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
+}
+
+inline string_t Extract(const string_t &input, Vector &result, const RE2 &re, const duckdb_re2::StringPiece &rewrite) {
+	string extracted;
+	RE2::Extract(input.GetString(), re, rewrite, &extracted);
+	return StringVector::AddString(result, extracted.c_str(), extracted.size());
+}
+
+} // namespace regexp_util
+
+struct RegexpExtractAll {
+	static void Execute(DataChunk &args, ExpressionState &state, Vector &result);
+	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
+	                                     vector<unique_ptr<Expression>> &arguments);
+	static unique_ptr<FunctionLocalState> InitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
+	                                                     FunctionData *bind_data);
+};
+
 struct RegexpBaseBindData : public FunctionData {
 	RegexpBaseBindData();
 	RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern = true);
@@ -61,14 +88,67 @@ struct RegexpExtractBindData : public RegexpBaseBindData {
 	bool Equals(const FunctionData &other_p) const override;
 };
 
+struct RegexStringPieceArgs {
+	RegexStringPieceArgs() : size(0), capacity(0), group_buffer(nullptr) {
+	}
+	void Init(idx_t size) {
+		this->size = size;
+		// Allocate for one extra, for the all-encompassing match group
+		this->capacity = size + 1;
+		group_buffer = AllocateArray<duckdb_re2::StringPiece>(capacity);
+	}
+	void SetSize(idx_t size) {
+		this->size = size;
+		if (size + 1 > capacity) {
+			Clear();
+			Init(size);
+		}
+	}
+
+	RegexStringPieceArgs &operator=(RegexStringPieceArgs &&other) {
+		std::swap(this->size, other.size);
+		std::swap(this->capacity, other.capacity);
+		std::swap(this->group_buffer, other.group_buffer);
+		return *this;
+	}
+
+	~RegexStringPieceArgs() {
+		Clear();
+	}
+
+private:
+	void Clear() {
+		DeleteArray<duckdb_re2::StringPiece>(group_buffer, capacity);
+		group_buffer = nullptr;
+
+		size = 0;
+		capacity = 0;
+	}
+
+public:
+	idx_t size;
+	//! The currently allocated capacity for the groups
+	idx_t capacity;
+	//! Used by ExtractAll to pre-allocate the storage for the groups
+	duckdb_re2::StringPiece *group_buffer;
+};
+
 struct RegexLocalState : public FunctionLocalState {
-	explicit RegexLocalState(RegexpBaseBindData &info)
+	explicit RegexLocalState(RegexpBaseBindData &info, bool extract_all = false)
 	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
 	                       info.options) {
+		if (extract_all) {
+			auto group_count_p = constant_pattern.NumberOfCapturingGroups();
+			if (group_count_p != -1) {
+				group_buffer.Init(group_count_p);
+			}
+		}
 		D_ASSERT(info.constant_pattern);
 	}
 
 	RE2 constant_pattern;
+	//! Used by regexp_extract_all to pre-allocate the args
+	RegexStringPieceArgs group_buffer;
 };
 
 unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,

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

@@ -213,4 +213,8 @@ struct JaroWinklerFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct HexFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb

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

@@ -29,13 +29,13 @@ class ScalarFunctionCatalogEntry;
 
 struct FunctionStatisticsInput {
 	FunctionStatisticsInput(BoundFunctionExpression &expr_p, FunctionData *bind_data_p,
-	                        vector<unique_ptr<BaseStatistics>> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
+	                        vector<BaseStatistics> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
 	    : expr(expr_p), bind_data(bind_data_p), child_stats(child_stats_p), expr_ptr(expr_ptr_p) {
 	}
 
 	BoundFunctionExpression &expr;
 	FunctionData *bind_data;
-	vector<unique_ptr<BaseStatistics>> &child_stats;
+	vector<BaseStatistics> &child_stats;
 	unique_ptr<Expression> *expr_ptr;
 };
 

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

@@ -32,7 +32,18 @@ enum class ArrowDateTimeType : uint8_t {
 	NANOSECONDS = 2,
 	SECONDS = 3,
 	DAYS = 4,
-	MONTHS = 5
+	MONTHS = 5,
+	MONTH_DAY_NANO = 6
+};
+
+struct ArrowInterval {
+	int32_t months;
+	int32_t days;
+	int64_t nanoseconds;
+
+	inline bool operator==(const ArrowInterval &rhs) const {
+		return this->days == rhs.days && this->months == rhs.months && this->nanoseconds == rhs.nanoseconds;
+	}
 };
 
 struct ArrowConvertData {

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

@@ -11,6 +11,8 @@
 #include "duckdb/common/enums/operator_result_type.hpp"
 #include "duckdb/execution/execution_context.hpp"
 #include "duckdb/function/function.hpp"
+#include "duckdb/planner/bind_context.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/storage/statistics/node_statistics.hpp"
 
 #include <functional>
@@ -136,6 +138,7 @@ public:
 
 typedef unique_ptr<FunctionData> (*table_function_bind_t)(ClientContext &context, TableFunctionBindInput &input,
                                                           vector<LogicalType> &return_types, vector<string> &names);
+typedef unique_ptr<TableRef> (*table_function_bind_replace_t)(ClientContext &context, TableFunctionBindInput &input);
 typedef unique_ptr<GlobalTableFunctionState> (*table_function_init_global_t)(ClientContext &context,
                                                                              TableFunctionInitInput &input);
 typedef unique_ptr<LocalTableFunctionState> (*table_function_init_local_t)(ExecutionContext &context,
@@ -185,6 +188,11 @@ public:
 	//! This function is used for determining the return type of a table producing function and returning bind data
 	//! The returned FunctionData object should be constant and should not be changed during execution.
 	table_function_bind_t bind;
+	//! (Optional) Bind replace function
+	//! This function is called before the regular bind function. It allows returning a TableRef will be used to
+	//! to generate a logical plan that replaces the LogicalGet of a regularly bound TableFunction. The BindReplace can
+	//! also return a nullptr to indicate a regular bind needs to be performed instead.
+	table_function_bind_replace_t bind_replace;
 	//! (Optional) global init function
 	//! Initialize the global operator state of the function.
 	//! The global operator state is used to keep track of the progress in the table function and is shared between
@@ -235,6 +243,8 @@ public:
 	bool filter_prune;
 	//! Additional function info, passed to the bind
 	shared_ptr<TableFunctionInfo> function_info;
+
+	DUCKDB_API bool Equal(const TableFunction &rhs) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp

@@ -40,6 +40,7 @@ struct ExtractStatementsWrapper {
 
 struct PendingStatementWrapper {
 	unique_ptr<PendingQueryResult> statement;
+	bool allow_streaming;
 };
 
 struct ArrowResultWrapper {
@@ -56,6 +57,7 @@ struct AppenderWrapper {
 enum class CAPIResultSetType : uint8_t {
 	CAPI_RESULT_TYPE_NONE = 0,
 	CAPI_RESULT_TYPE_MATERIALIZED,
+	CAPI_RESULT_TYPE_STREAMING,
 	CAPI_RESULT_TYPE_DEPRECATED
 };
 

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

@@ -20,7 +20,7 @@ class BufferedFileWriter;
 class ClientContext;
 class CatalogSearchPath;
 class FileOpener;
-class HTTPStats;
+class HTTPState;
 class QueryProfiler;
 class QueryProfilerHistory;
 class PreparedStatementData;
@@ -52,8 +52,8 @@ struct ClientData {
 	//! The file opener of the client context
 	unique_ptr<FileOpener> file_opener;
 
-	//! Statistics on HTTP traffic
-	unique_ptr<HTTPStats> http_stats;
+	//! HTTP State in this query
+	unique_ptr<HTTPState> http_state;
 
 	//! The file search path
 	string file_search_path;

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

@@ -30,6 +30,7 @@
 #include "duckdb/planner/operator_extension.hpp"
 
 namespace duckdb {
+class BufferPool;
 class CastFunctionSet;
 class ClientContext;
 class ErrorManager;
@@ -186,6 +187,8 @@ public:
 	vector<std::unique_ptr<OperatorExtension>> operator_extensions;
 	//! Extensions made to storage
 	case_insensitive_map_t<std::unique_ptr<StorageExtension>> storage_extensions;
+	//! A buffer pool can be shared across multiple databases (if desired).
+	shared_ptr<BufferPool> buffer_pool;
 
 public:
 	DUCKDB_API static DBConfig &GetConfig(ClientContext &context);

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

@@ -47,6 +47,8 @@ public:
 		return result;
 	}
 
+	ClientContext *GetConnection(DatabaseInstance *db);
+
 	static ConnectionManager &Get(DatabaseInstance &db);
 	static ConnectionManager &Get(ClientContext &context);
 

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

@@ -35,6 +35,7 @@ public:
 	DBConfig config;
 
 public:
+	BufferPool &GetBufferPool();
 	DUCKDB_API BufferManager &GetBufferManager();
 	DUCKDB_API DatabaseManager &GetDatabaseManager();
 	DUCKDB_API FileSystem &GetFileSystem();

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

@@ -55,6 +55,7 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
     {"json_transform_strict", "json"},
     {"json_type", "json"},
     {"json_valid", "json"},
+    {"json_serialize_sql", "json"},
     {"make_timestamptz", "icu"},
     {"parquet_metadata", "parquet"},
     {"parquet_scan", "parquet"},
@@ -96,6 +97,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"http_retry_backoff", "httpfs"},
     {"http_retry_wait_ms", "httpfs"},
     {"http_timeout", "httpfs"},
+    {"force_download", "httpfs"},
     {"s3_access_key_id", "httpfs"},
     {"s3_endpoint", "httpfs"},
     {"s3_region", "httpfs"},

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

@@ -48,6 +48,8 @@ public:
 public:
 	//! Returns the stored error message
 	DUCKDB_API const string &GetError();
+	//! Returns the stored error object
+	DUCKDB_API PreservedError &GetErrorObject();
 	//! Returns whether or not an error occurred
 	DUCKDB_API bool HasError() const;
 	//! Returns the number of columns in the result

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

@@ -14,10 +14,11 @@ namespace duckdb {
 
 class ExplainRelation : public Relation {
 public:
-	explicit ExplainRelation(shared_ptr<Relation> child);
+	explicit ExplainRelation(shared_ptr<Relation> child, ExplainType type = ExplainType::EXPLAIN_STANDARD);
 
 	shared_ptr<Relation> child;
 	vector<ColumnDefinition> columns;
+	ExplainType type;
 
 public:
 	BoundStatement Bind(Binder &binder) override;

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

@@ -17,6 +17,7 @@
 #include "duckdb/common/named_parameter_map.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/external_dependencies.hpp"
+#include "duckdb/parser/statement/explain_statement.hpp"
 
 #include <memory>
 
@@ -66,7 +67,7 @@ public:
 	DUCKDB_API unique_ptr<QueryResult> Query(const string &name, const string &sql);
 
 	//! Explain the query plan of this relation
-	DUCKDB_API unique_ptr<QueryResult> Explain();
+	DUCKDB_API unique_ptr<QueryResult> Explain(ExplainType type = ExplainType::EXPLAIN_STANDARD);
 
 	DUCKDB_API virtual unique_ptr<TableRef> GetTableRef();
 	DUCKDB_API virtual bool IsReadOnly() {

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

@@ -67,6 +67,8 @@ private:
 	unique_ptr<LogicalOperator> PushdownSingleJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
 	                                               unordered_set<idx_t> &right_bindings);
 
+	//! Push any remaining filters into a LogicalFilter at this level
+	unique_ptr<LogicalOperator> PushFinalFilters(unique_ptr<LogicalOperator> op);
 	// Finish pushing down at this operator, creating a LogicalFilter to store any of the stored filters and recursively
 	// pushing down into its children (if any)
 	unique_ptr<LogicalOperator> FinishPushdown(unique_ptr<LogicalOperator> op);

package/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp

@@ -106,7 +106,7 @@ private:
 	//! If there are multiple equivalence sets, they are merged.
 	void AddToEquivalenceSets(FilterInfo *filter_info, vector<idx_t> matching_equivalent_sets);
 
-	TableFilterSet *GetTableFilters(LogicalOperator *op);
+	TableFilterSet *GetTableFilters(LogicalOperator *op, idx_t table_index);
 
 	void AddRelationTdom(FilterInfo *filter_info);
 	bool EmptyFilter(FilterInfo *filter_info);
@@ -115,7 +115,7 @@ private:
 	                            unique_ptr<BaseStatistics> base_stats);
 	idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter *fil,
 	                           unique_ptr<BaseStatistics> base_stats);
-	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters);
+	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters, idx_t table_index);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/rule/list.hpp

@@ -10,3 +10,4 @@
 #include "duckdb/optimizer/rule/move_constants.hpp"
 #include "duckdb/optimizer/rule/enum_comparison.hpp"
 #include "duckdb/optimizer/rule/regex_optimizations.hpp"
+#include "duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp"

package/src/duckdb/src/include/duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp

@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/optimizer/rule.hpp"
+#include "duckdb/parser/expression_map.hpp"
+
+namespace duckdb {
+
+class OrderedAggregateOptimizer : public Rule {
+public:
+	explicit OrderedAggregateOptimizer(ExpressionRewriter &rewriter);
+
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	                             bool is_root) override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/common_table_expression_info.hpp

@@ -17,6 +17,10 @@ class SelectStatement;
 struct CommonTableExpressionInfo {
 	vector<string> aliases;
 	unique_ptr<SelectStatement> query;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<CommonTableExpressionInfo> FormatDeserialize(FormatDeserializer &deserializer);
+	unique_ptr<CommonTableExpressionInfo> Copy();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp

@@ -31,6 +31,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+
 public:
 	template <class T, class BASE>
 	static string ToString(const T &entry) {

package/src/duckdb/src/include/duckdb/parser/expression/bound_expression.hpp

@@ -33,6 +33,8 @@ public:
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 struct CaseCheck {
 	unique_ptr<ParsedExpression> when_expr;
 	unique_ptr<ParsedExpression> then_expr;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static CaseCheck FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 //! The CaseExpression represents a CASE expression in the query
@@ -35,6 +38,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp

@@ -34,6 +34,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp

@@ -31,5 +31,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp

@@ -45,5 +45,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp

@@ -30,6 +30,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp

@@ -34,6 +34,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp

@@ -31,6 +31,9 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp

@@ -27,5 +27,6 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -55,13 +55,15 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 	void Verify() const override;
 
 public:
-	template <class T, class BASE>
+	template <class T, class BASE, class ORDER_MODIFIER = OrderModifier>
 	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
-	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
+	                       bool distinct = false, BASE *filter = nullptr, ORDER_MODIFIER *order_bys = nullptr,
 	                       bool export_state = false, bool add_alias = false) {
 		if (is_operator) {
 			// built-in operator

package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp

@@ -37,6 +37,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -32,6 +32,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp

@@ -34,5 +34,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp

@@ -30,5 +30,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp

@@ -24,8 +24,8 @@ public:
 	case_insensitive_set_t exclude_list;
 	//! List of columns to replace with another expression
 	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
-	//! Regular expression to select columns (if any)
-	string regex;
+	//! The expression to select the columns (regular expression or list)
+	unique_ptr<ParsedExpression> expr;
 	//! Whether or not this is a COLUMNS expression
 	bool columns = false;
 
@@ -38,5 +38,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp

@@ -45,5 +45,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp

@@ -25,6 +25,8 @@ enum class WindowBoundary : uint8_t {
 	EXPR_FOLLOWING_RANGE = 8
 };
 
+const char *ToString(WindowBoundary value);
+
 //! The WindowExpression represents a window function in the query. They are a special case of aggregates which is why
 //! they inherit from them.
 class WindowExpression : public ParsedExpression {
@@ -71,6 +73,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE, class ORDER_NODE>
@@ -200,4 +204,5 @@ public:
 		return result;
 	}
 };
+
 } // namespace duckdb

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

@@ -20,7 +20,8 @@ enum class AlterType : uint8_t {
 	ALTER_VIEW = 2,
 	ALTER_SEQUENCE = 3,
 	CHANGE_OWNERSHIP = 4,
-	ALTER_FUNCTION = 5
+	ALTER_SCALAR_FUNCTION = 5,
+	ALTER_TABLE_FUNCTION = 6
 };
 
 struct AlterEntryData {
@@ -58,6 +59,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	static unique_ptr<AlterInfo> Deserialize(Deserializer &source);
+	virtual string GetColumnName() const {
+		return "";
+	};
 
 	AlterEntryData GetAlterEntryData() const;
 };