duckdb 1.3.3-dev4.0 → 1.3.3

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

@@ -18,7 +18,7 @@ class MetaTransaction;
 
 class ValidChecker {
 public:
-	explicit ValidChecker(DatabaseInstance &db);
+	ValidChecker();
 
 	DUCKDB_API static ValidChecker &Get(DatabaseInstance &db);
 	DUCKDB_API static ValidChecker &Get(MetaTransaction &transaction);
@@ -42,13 +42,10 @@ public:
 	}
 
 private:
+	//! Set to true if a fatal exception has occurred
 	mutex invalidate_lock;
-	//! Set to true when encountering a fatal exception.
 	atomic<bool> is_invalidated;
-	//! The message invalidating the database instance.
 	string invalidated_msg;
-	//! The database instance.
-	DatabaseInstance &db;
 };
 
 } // namespace duckdb

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

@@ -35,7 +35,7 @@ public:
 	void VisitExpression(unique_ptr<Expression> *expression) override {};
 
 private:
-	bool TryFlipJoinChildren(LogicalOperator &op) const;
+	void TryFlipJoinChildren(LogicalOperator &op) const;
 	static idx_t ChildHasJoins(LogicalOperator &op);
 
 	static BuildSize GetBuildSizes(const LogicalOperator &op, idx_t lhs_cardinality, idx_t rhs_cardinality);

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

@@ -28,7 +28,7 @@ public:
 	void VisitOperator(LogicalOperator &op) override;
 
 public:
-	static void ExtractColumnBindings(const Expression &expr, vector<ColumnBinding> &bindings);
+	static void ExtractColumnBindings(Expression &expr, vector<ColumnBinding> &bindings);
 
 protected:
 	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;

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

@@ -76,11 +76,7 @@ typedef column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map_t;
 class CompressedMaterialization {
 private:
 	//! Somewhat defensive constants that try to limit when compressed materialization is triggered for joins
-	//! We only consider compressed materialization for joins when the build cardinality is greater than this
 	static constexpr idx_t JOIN_BUILD_CARDINALITY_THRESHOLD = 1048576;
-	//! If the cardinality > threshold, we always perform compressed materialization if there are this many columns
-	static constexpr idx_t JOIN_BUILD_COLUMN_COUNT_THRESHOLD = 20;
-	//! If not, we perform compressed materialization if join result cardinality > build cardinality * this threshold
 	static constexpr double JOIN_CARDINALITY_RATIO_THRESHOLD = 8;
 
 public:

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

@@ -74,9 +74,6 @@ private:
 	unique_ptr<LogicalOperator> PushdownLeftJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
 	                                             unordered_set<idx_t> &right_bindings);
 
-	// Pushdown an outer join
-	unique_ptr<LogicalOperator> PushdownOuterJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                              unordered_set<idx_t> &right_bindings);
 	unique_ptr<LogicalOperator> PushdownSemiAntiJoin(unique_ptr<LogicalOperator> op);
 	// Pushdown a mark join
 	unique_ptr<LogicalOperator> PushdownMarkJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
@@ -99,7 +96,7 @@ private:
 	FilterResult AddFilter(unique_ptr<Expression> expr);
 	//! Extract filter bindings to compare them with expressions in an operator and determine if the filter
 	//! can be pushed down
-	void ExtractFilterBindings(const Expression &expr, vector<ColumnBinding> &bindings);
+	void ExtractFilterBindings(Expression &expr, vector<ColumnBinding> &bindings);
 	//! Generate filters from the current set of filters stored in the FilterCombiner
 	void GenerateFilters();
 	//! if there are filters in this FilterPushdown node, push them into the combiner

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

@@ -61,9 +61,6 @@ private:
 	//! Stats of Delim Scans of the Delim Join that is currently being optimized
 	optional_ptr<RelationStats> delim_scan_stats;
 	idx_t depth;
-
-public:
-	unordered_set<idx_t> recursive_cte_indexes;
 };
 
 } // namespace duckdb

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

@@ -33,7 +33,7 @@ private:
 	vector<idx_t> GetOrInsertRowIds(LogicalGet &get);
 
 	void ReplaceTopLevelTableIndex(LogicalOperator &op, idx_t new_index);
-	void ReplaceTableReferences(unique_ptr<Expression> &expr, idx_t new_table_index);
+	void ReplaceTableReferences(Expression &expr, idx_t new_table_index);
 	unique_ptr<Expression> GetExpression(LogicalOperator &op, idx_t column_index);
 	void ReplaceExpressionReferences(LogicalOperator &next_op, unique_ptr<Expression> &expr);
 	bool OptimizeLargeLimit(LogicalLimit &limit, idx_t limit_val, bool has_offset);

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

@@ -4,7 +4,6 @@
 #include "duckdb/optimizer/rule/conjunction_simplification.hpp"
 #include "duckdb/optimizer/rule/constant_folding.hpp"
 #include "duckdb/optimizer/rule/date_part_simplification.hpp"
-#include "duckdb/optimizer/rule/date_trunc_simplification.hpp"
 #include "duckdb/optimizer/rule/distributivity.hpp"
 #include "duckdb/optimizer/rule/empty_needle_removal.hpp"
 #include "duckdb/optimizer/rule/like_optimizations.hpp"

package/src/duckdb/src/include/duckdb/parallel/interrupt.hpp

@@ -69,13 +69,13 @@ public:
 	}
 
 	void PreventBlocking(const unique_lock<mutex> &guard) {
-		VerifyLock(guard);
+		D_ASSERT(guard.mutex() && RefersToSameObject(*guard.mutex(), lock));
 		can_block = false;
 	}
 
 	//! Add a task to 'blocked_tasks' before returning SourceResultType::BLOCKED (must hold the lock)
 	bool BlockTask(const unique_lock<mutex> &guard, const InterruptState &interrupt_state) {
-		VerifyLock(guard);
+		D_ASSERT(guard.mutex() && RefersToSameObject(*guard.mutex(), lock));
 		if (can_block) {
 			blocked_tasks.push_back(interrupt_state);
 			return true;
@@ -85,7 +85,7 @@ public:
 
 	//! Unblock all tasks (must hold the lock)
 	bool UnblockTasks(const unique_lock<mutex> &guard) {
-		VerifyLock(guard);
+		D_ASSERT(guard.mutex() && RefersToSameObject(*guard.mutex(), lock));
 		if (blocked_tasks.empty()) {
 			return false;
 		}
@@ -104,12 +104,6 @@ public:
 		return BlockTask(guard, interrupt_state) ? SourceResultType::BLOCKED : SourceResultType::FINISHED;
 	}
 
-	void VerifyLock(const unique_lock<mutex> &guard) const {
-#ifdef DEBUG
-		D_ASSERT(guard.mutex() && RefersToSameObject(*guard.mutex(), lock));
-#endif
-	}
-
 private:
 	//! Whether we can block tasks
 	atomic<bool> can_block {true};

package/src/duckdb/src/include/duckdb/parallel/task_scheduler.hpp

@@ -48,7 +48,6 @@ public:
 	unique_ptr<ProducerToken> CreateProducer();
 	//! Schedule a task to be executed by the task scheduler
 	void ScheduleTask(ProducerToken &producer, shared_ptr<Task> task);
-	void ScheduleTasks(ProducerToken &producer, vector<shared_ptr<Task>> &tasks);
 	//! Fetches a task from a specific producer, returns true if successful or false if no tasks were available
 	bool GetTaskFromProducer(ProducerToken &token, shared_ptr<Task> &task);
 	//! Run tasks forever until "marker" is set to false, "marker" must remain valid until the thread is joined

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

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/common/vector.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/common/enums/cte_materialize.hpp"
 
 namespace duckdb {
@@ -24,8 +24,6 @@ struct CommonTableExpressionInfo {
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<CommonTableExpressionInfo> Deserialize(Deserializer &deserializer);
 	unique_ptr<CommonTableExpressionInfo> Copy();
-
-	~CommonTableExpressionInfo();
 };
 
 } // namespace duckdb

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

@@ -134,17 +134,14 @@ struct RenameFieldInfo : public AlterTableInfo {
 	RenameFieldInfo(AlterEntryData data, vector<string> column_path, string new_name_p);
 	~RenameFieldInfo() override;
 
-	//! Path to source field.
+	//! Path to source field
 	vector<string> column_path;
-	//! New name of the column (field).
+	//! Column new name
 	string new_name;
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	string ToString() const override;
-	string GetColumnName() const override {
-		return column_path[0];
-	}
 
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
@@ -204,19 +201,16 @@ struct AddFieldInfo : public AlterTableInfo {
 	AddFieldInfo(AlterEntryData data, vector<string> column_path, ColumnDefinition new_field, bool if_field_not_exists);
 	~AddFieldInfo() override;
 
-	//! Path to source field.
+	//! The path to the struct
 	vector<string> column_path;
-	//! New field to add.
+	//! New field to add to the struct
 	ColumnDefinition new_field;
-	//! Whether or not an error should be thrown if the field does not exist.
+	//! Whether or not an error should be thrown if the field exist
 	bool if_field_not_exists;
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	string ToString() const override;
-	string GetColumnName() const override {
-		return column_path[0];
-	}
 
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
@@ -259,20 +253,16 @@ struct RemoveFieldInfo : public AlterTableInfo {
 	RemoveFieldInfo(AlterEntryData data, vector<string> column_path, bool if_column_exists, bool cascade);
 	~RemoveFieldInfo() override;
 
-	//! Path to source field.
+	//! The path to the field to remove
 	vector<string> column_path;
-	//! Whether or not an error should be thrown if the column does not exist.
+	//! Whether or not an error should be thrown if the column does not exist
 	bool if_column_exists;
-	//! Whether or not the column should be removed if a dependency conflict arises (used by GENERATED columns).
+	//! Whether or not the column should be removed if a dependency conflict arises (used by GENERATED columns)
 	bool cascade;
 
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	string ToString() const override;
-	string GetColumnName() const override {
-		return column_path[0];
-	}
-
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
 

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

@@ -9,10 +9,11 @@
 #pragma once
 
 #include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/common/vector.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/enums/on_create_conflict.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/storage/storage_options.hpp"
 
 namespace duckdb {
 
@@ -29,13 +30,13 @@ public:
 	//! The path to the attached database
 	string path;
 	//! Set of (key, value) options
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> parsed_options;
-	//! Set of bound (key, value) options
 	unordered_map<string, Value> options;
 	//! What to do on create conflict
 	OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 
 public:
+	//! Returns the storage options
+	StorageOptions GetStorageOptions() const;
 	//! Copies this AttachInfo and returns an unique pointer to the new AttachInfo.
 	unique_ptr<AttachInfo> Copy() const;
 	string ToString() const;

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

@@ -24,7 +24,8 @@ public:
 	static constexpr const ParseInfoType TYPE = ParseInfoType::COPY_INFO;
 
 public:
-	CopyInfo();
+	CopyInfo() : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(DEFAULT_SCHEMA), is_format_auto_detected(true) {
+	}
 
 	//! The catalog name to copy to/from
 	string catalog;
@@ -40,19 +41,16 @@ public:
 	string format;
 	//! If the format is manually set (i.e., via the format parameter) or was discovered by inspecting the file path
 	bool is_format_auto_detected;
-	//! Expression to determine the file path (if any)
-	unique_ptr<ParsedExpression> file_path_expression;
 	//! The file path to copy to/from
 	string file_path;
 	//! Set of (key, value) options
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> parsed_options;
-	//! Set of (key, value) options
 	case_insensitive_map_t<vector<Value>> options;
 	//! The SQL statement used instead of a table when copying data out to a file
 	unique_ptr<QueryNode> select_statement;
 
 public:
-	string CopyOptionsToString() const;
+	static string CopyOptionsToString(const string &format, bool is_format_auto_detected,
+	                                  const case_insensitive_map_t<vector<Value>> &options);
 
 public:
 	unique_ptr<CopyInfo> Copy() const;

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

@@ -60,8 +60,6 @@ public:
 	DUCKDB_API void CopyProperties(CreateInfo &other) const;
 	//! Generates an alter statement from the create statement - used for OnCreateConflict::ALTER_ON_CONFLICT
 	DUCKDB_API virtual unique_ptr<AlterInfo> GetAlterInfo() const;
-	//! Returns a string like "CREATE (OR REPLACE) (TEMPORARY) <entry> (IF NOT EXISTS) " for TABLE/VIEW/TYPE/MACRO
-	DUCKDB_API string GetCreatePrefix(const string &entry) const;
 
 	virtual string ToString() const {
 		throw NotImplementedException("ToString not supported for this type of CreateInfo: '%s'",

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

@@ -35,20 +35,6 @@ public:
 	EnumerateQueryNodeModifiers(QueryNode &node,
 	                            const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback);
 
-	static void VisitExpressionClass(const ParsedExpression &expr, ExpressionClass expr_class,
-	                                 const std::function<void(const ParsedExpression &child)> &callback);
-	static void VisitExpressionClassMutable(ParsedExpression &expr, ExpressionClass expr_class,
-	                                        const std::function<void(ParsedExpression &child)> &callback);
-
-	template <class T>
-	static void VisitExpressionMutable(ParsedExpression &expr, const std::function<void(T &child)> &callback) {
-		VisitExpressionClassMutable(expr, T::TYPE, [&](ParsedExpression &child) { callback(child.Cast<T>()); });
-	}
-	template <class T>
-	static void VisitExpression(const ParsedExpression &expr, const std::function<void(const T &child)> &callback) {
-		VisitExpressionClass(expr, T::TYPE, [&](const ParsedExpression &child) { callback(child.Cast<T>()); });
-	}
-
 private:
 	static void DefaultRefCallback(TableRef &ref) {}; // NOP
 };

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

@@ -68,8 +68,6 @@ public:
 	                                                                    ParserOptions options = ParserOptions());
 	//! Parses a column list (i.e. as found in a CREATE TABLE statement)
 	static ColumnList ParseColumnList(const string &column_list, ParserOptions options = ParserOptions());
-	static ColumnDefinition ParseColumnDefinition(const string &column_definition,
-	                                              ParserOptions options = ParserOptions());
 
 	static bool StripUnicodeSpaces(const string &query_str, string &new_query);
 

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

@@ -39,8 +39,6 @@ struct QualifiedColumnName {
 	string table;
 	string column;
 
-	static QualifiedColumnName Parse(string &input);
-
 	string ToString() const;
 
 	void Serialize(Serializer &serializer) const;

package/src/duckdb/src/include/duckdb/parser/query_node/cte_node.hpp

@@ -30,8 +30,6 @@ public:
 	//! Aliases of the CTE node
 	vector<string> aliases;
 
-	CTEMaterialize materialized = CTEMaterialize::CTE_MATERIALIZE_DEFAULT;
-
 	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
 		return query->GetSelectList();
 	}

package/src/duckdb/src/include/duckdb/parser/statement/list.hpp

@@ -14,7 +14,6 @@
 #include "duckdb/parser/statement/insert_statement.hpp"
 #include "duckdb/parser/statement/load_statement.hpp"
 #include "duckdb/parser/statement/logical_plan_statement.hpp"
-#include "duckdb/parser/statement/merge_into_statement.hpp"
 #include "duckdb/parser/statement/pragma_statement.hpp"
 #include "duckdb/parser/statement/prepare_statement.hpp"
 #include "duckdb/parser/statement/relation_statement.hpp"

package/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp

@@ -8,12 +8,15 @@
 
 #pragma once
 
-#include "duckdb/parser/query_node.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/sql_statement.hpp"
 #include "duckdb/parser/tableref.hpp"
+#include "duckdb/parser/query_node.hpp"
 
 namespace duckdb {
 
+class QueryNode;
 class Serializer;
 class Deserializer;
 

package/src/duckdb/src/include/duckdb/parser/statement/update_statement.hpp

@@ -22,7 +22,6 @@ public:
 
 public:
 	unique_ptr<UpdateSetInfo> Copy() const;
-	string ToString() const;
 
 public:
 	// The condition that needs to be met to perform the update

package/src/duckdb/src/include/duckdb/parser/tableref/column_data_ref.hpp

@@ -20,14 +20,19 @@ public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::COLUMN_DATA;
 
 public:
-	explicit ColumnDataRef(optionally_owned_ptr<ColumnDataCollection> collection_p,
-	                       vector<string> expected_names = vector<string>());
+	explicit ColumnDataRef(shared_ptr<ColumnDataCollection> collection)
+	    : TableRef(TableReferenceType::COLUMN_DATA), collection(std::move(collection)) {
+	}
+	ColumnDataRef(shared_ptr<ColumnDataCollection> collection, vector<string> expected_names)
+	    : TableRef(TableReferenceType::COLUMN_DATA), expected_names(std::move(expected_names)),
+	      collection(std::move(collection)) {
+	}
 
 public:
 	//! The set of expected names
 	vector<string> expected_names;
-	//! (Optionally) the owned collection
-	optionally_owned_ptr<ColumnDataCollection> collection;
+	//! The collection to scan
+	shared_ptr<ColumnDataCollection> collection;
 
 public:
 	string ToString() const override;

package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp

@@ -43,8 +43,6 @@ public:
 	vector<unique_ptr<ParsedExpression>> duplicate_eliminated_columns;
 	//! If we have duplicate eliminated columns if the delim is flipped
 	bool delim_flipped = false;
-	//! Whether or not this is an implicit cross join
-	bool is_implicit = false;
 
 public:
 	string ToString() const override;

package/src/duckdb/src/include/duckdb/parser/tableref/list.hpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/tableref/bound_ref_wrapper.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/parser/tableref/column_data_ref.hpp"

package/src/duckdb/src/include/duckdb/parser/tableref/showref.hpp

@@ -16,7 +16,7 @@
 
 namespace duckdb {
 
-enum class ShowType : uint8_t { SUMMARY, DESCRIBE, SHOW_FROM };
+enum class ShowType : uint8_t { SUMMARY, DESCRIBE };
 
 //! Represents a SHOW/DESCRIBE/SUMMARIZE statement
 class ShowRef : public TableRef {
@@ -28,10 +28,6 @@ public:
 
 	//! The table name (if any)
 	string table_name;
-	//! The catalog name (if any)
-	string catalog_name;
-	//! The schema name (if any)
-	string schema_name;
 	//! The QueryNode of select query (if any)
 	unique_ptr<QueryNode> query;
 	//! Whether or not we are requesting a summary or a describe

package/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp

@@ -12,7 +12,6 @@
 #include "duckdb/parser/tableref.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/common/enums/ordinality_request_type.hpp"
 
 namespace duckdb {
 //! Represents a Table producing function
@@ -28,9 +27,6 @@ public:
 	// if the function takes a subquery as argument its in here
 	unique_ptr<SelectStatement> subquery;
 
-	//! Whether or not WITH ORDINALITY has been invoked
-	OrdinalityType with_ordinality = OrdinalityType::WITHOUT_ORDINALITY;
-
 public:
 	string ToString() const override;
 

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

@@ -43,7 +43,6 @@ class LoadStatement;
 class LogicalPlanStatement;
 class MultiStatement;
 class CopyDatabaseStatement;
-class MergeIntoStatement;
 
 //===--------------------------------------------------------------------===//
 // Query Node
@@ -93,7 +92,6 @@ class ForeignKeyConstraint;
 class TableRef;
 
 class BaseTableRef;
-class BoundRefWrapper;
 class JoinRef;
 class SubqueryRef;
 class TableFunctionRef;
@@ -107,6 +105,5 @@ class ShowRef;
 // Other
 //===--------------------------------------------------------------------===//
 class SampleOptions;
-class MergeIntoAction;
 
 } // namespace duckdb

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

@@ -142,9 +142,6 @@ private:
 	unique_ptr<SQLStatement> TransformDrop(duckdb_libpgquery::PGDropStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGInsertStmt node into a InsertStatement
 	unique_ptr<InsertStatement> TransformInsert(duckdb_libpgquery::PGInsertStmt &stmt);
-	InsertColumnOrder TransformColumnOrder(duckdb_libpgquery::PGInsertColumnOrder insert_column_order);
-
-	vector<string> TransformInsertColumns(duckdb_libpgquery::PGList &cols);
 
 	//! Transform a Postgres duckdb_libpgquery::T_PGOnConflictClause node into a OnConflictInfo
 	unique_ptr<OnConflictInfo> TransformOnConflictClause(duckdb_libpgquery::PGOnConflictClause *node,
@@ -194,9 +191,6 @@ private:
 	static bool TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry,
 	                                 bool root_entry = true);
 
-	unique_ptr<SQLStatement> TransformMergeInto(duckdb_libpgquery::PGMergeIntoStmt &stmt);
-	unique_ptr<MergeIntoAction> TransformMergeIntoAction(duckdb_libpgquery::PGMatchAction &action);
-
 	//===--------------------------------------------------------------------===//
 	// SetStatement Transform
 	//===--------------------------------------------------------------------===//
@@ -328,9 +322,6 @@ private:
 	//! Transform a VALUES list into a set of expressions
 	unique_ptr<TableRef> TransformValuesList(duckdb_libpgquery::PGList *list);
 
-	//! Transform using clause
-	vector<string> TransformUsingClause(duckdb_libpgquery::PGList &usingClause);
-
 	//! Transform a range var into a (schema) qualified name
 	QualifiedName TransformQualifiedName(duckdb_libpgquery::PGRangeVar &root);
 
@@ -376,6 +367,8 @@ private:
 
 	unique_ptr<MacroFunction> TransformMacroFunction(duckdb_libpgquery::PGFunctionDefinition &function);
 
+	void ParseGenericOptionListEntry(case_insensitive_map_t<vector<Value>> &result_options, string &name,
+	                                 duckdb_libpgquery::PGNode *arg);
 	vector<string> TransformNameList(duckdb_libpgquery::PGList &list);
 
 public:

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

@@ -97,9 +97,6 @@ public:
 	                  vector<ColumnIndex> &bound_column_ids, TableCatalogEntry &entry, bool add_row_id = true);
 	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
 	                  vector<ColumnIndex> &bound_column_ids, const string &table_name);
-	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
-	                  vector<ColumnIndex> &bound_column_ids, TableCatalogEntry &entry,
-	                  virtual_column_map_t virtual_columns);
 	//! Adds a call to a table function with the given alias to the BindContext.
 	void AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
 	                      const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
@@ -122,8 +119,6 @@ public:
 	void AddCTEBinding(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
 	                   bool using_key = false);
 
-	void RemoveCTEBinding(const string &alias);
-
 	//! Add an implicit join condition (e.g. USING (x))
 	void AddUsingBinding(const string &column_name, UsingColumnSet &set);