duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -8,11 +8,11 @@
 
 #pragma once
 
+#include "duckdb/common/atomic.hpp"
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/parallel/task.hpp"
-#include "duckdb/common/atomic.hpp"
 
 namespace duckdb {
 
@@ -76,6 +76,13 @@ public:
 
 	//! Set the allocator flush threshold
 	void SetAllocatorFlushTreshold(idx_t threshold);
+	//! Sets the allocator background thread
+	void SetAllocatorBackgroundThreads(bool enable);
+
+	//! Get the number of the CPU on which the calling thread is currently executing.
+	//! Fallback to calling thread id if CPU number is not available.
+	//! Result do not need to be exact 'return 0' is a valid fallback strategy
+	static idx_t GetEstimatedCPUId();
 
 private:
 	void RelaunchThreadsInternal(int32_t n);
@@ -92,6 +99,8 @@ private:
 	vector<unique_ptr<atomic<bool>>> markers;
 	//! The threshold after which to flush the allocator after completing a task
 	atomic<idx_t> allocator_flush_threshold;
+	//! Whether allocator background threads are enabled
+	atomic<bool> allocator_background_threads;
 	//! Requested thread count (set by the 'threads' setting)
 	atomic<int32_t> requested_thread_count;
 	//! The amount of threads currently running

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

@@ -61,6 +61,9 @@ public:
 
 	void Verify() const override;
 
+	//! Returns true, if the function has a lambda expression as a child.
+	bool IsLambdaFunction() const;
+
 public:
 	template <class T, class BASE, class ORDER_MODIFIER = OrderModifier>
 	static string ToString(const T &entry, const string &catalog, const string &schema, const string &function_name,
@@ -89,7 +92,7 @@ public:
 		if (!schema.empty()) {
 			result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
 		}
-		result += function_name;
+		result += KeywordHelper::WriteOptionallyQuoted(function_name);
 		result += "(";
 		if (distinct) {
 			result += "DISTINCT ";

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

@@ -31,11 +31,16 @@ public:
 	unique_ptr<ParsedExpression> expr;
 	//! Whether or not this is a COLUMNS expression
 	bool columns = false;
+	//! Whether the columns are unpacked
+	bool unpacked = false;
 
 public:
 	string ToString() const override;
 
 	static bool Equal(const StarExpression &a, const StarExpression &b);
+	static bool IsStar(const ParsedExpression &a);
+	static bool IsColumns(const ParsedExpression &a);
+	static bool IsColumnsUnpacked(const ParsedExpression &a);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -36,6 +36,11 @@ public:
 	CatalogType GetCatalogType() const override;
 	unique_ptr<AlterInfo> Copy() const override;
 	string ToString() const override;
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
+
+	explicit ChangeOwnershipInfo();
 };
 
 //===--------------------------------------------------------------------===//

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

@@ -34,6 +34,11 @@ public:
 	OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 
 public:
+	//! Returns the block allocation size, which is the allocation size of blocks for this attached database file.
+	//! Returns DConstants::INVALID_INDEX, if not provided. This is NOT the actual memory available on a block
+	//! (block_size), even though the corresponding option we expose to the user is called "block_size".
+	optional_idx GetBlockAllocSize() 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/create_index_info.hpp

@@ -48,6 +48,8 @@ public:
 	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
 
 	string ToString() const override;
+	vector<string> ExpressionsToList() const;
+	string ExpressionsToString() const;
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
 };

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

@@ -16,13 +16,23 @@ namespace duckdb {
 struct CreateMacroInfo : public CreateFunctionInfo {
 	explicit CreateMacroInfo(CatalogType type);
 
-	unique_ptr<MacroFunction> function;
+	vector<unique_ptr<MacroFunction>> macros;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override;
 
+	string ToString() const override;
 	DUCKDB_API void Serialize(Serializer &serializer) const override;
 	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
+
+	//! This is a weird function that exists only for backwards compatibility of serialization
+	//! Essentially we used to only support a single function in the CreateMacroInfo
+	//! In order to not break backwards/forwards compatibility, we serialize the first function in the old manner
+	//! Extra functions are serialized if present in a separate field
+	vector<unique_ptr<MacroFunction>> GetAllButFirstFunction() const;
+	//! This is a weird constructor that exists only for serialization, similarly to GetAllButFirstFunction
+	CreateMacroInfo(CatalogType type, unique_ptr<MacroFunction> function,
+	                vector<unique_ptr<MacroFunction>> extra_functions);
 };
 
 } // namespace duckdb

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

@@ -14,6 +14,12 @@ namespace duckdb {
 
 enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
 
+enum class TransactionModifierType : uint8_t {
+	TRANSACTION_DEFAULT_MODIFIER,
+	TRANSACTION_READ_ONLY,
+	TRANSACTION_READ_WRITE
+};
+
 struct TransactionInfo : public ParseInfo {
 public:
 	static constexpr const ParseInfoType TYPE = ParseInfoType::TRANSACTION_INFO;
@@ -23,12 +29,15 @@ public:
 
 	//! The type of transaction statement
 	TransactionType type;
+	//! Whether or not a transaction can make modifications to the database
+	TransactionModifierType modifier;
 
 public:
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 
 	string ToString() const;
+	unique_ptr<TransactionInfo> Copy() const;
 
 private:
 	TransactionInfo();

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

@@ -24,12 +24,19 @@ public:
 	                              const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
 
 	static void EnumerateTableRefChildren(TableRef &ref,
-	                                      const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-	static void EnumerateQueryNodeChildren(QueryNode &node,
-	                                       const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-
-	static void EnumerateQueryNodeModifiers(QueryNode &node,
-	                                        const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
+	                                      const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback,
+	                                      const std::function<void(TableRef &ref)> &ref_callback = DefaultRefCallback);
+	static void
+	EnumerateQueryNodeChildren(QueryNode &node,
+	                           const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback,
+	                           const std::function<void(TableRef &ref)> &ref_callback = DefaultRefCallback);
+
+	static void
+	EnumerateQueryNodeModifiers(QueryNode &node,
+	                            const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback);
+
+private:
+	static void DefaultRefCallback(TableRef &ref) {}; // NOP
 };
 
 } // namespace duckdb

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

@@ -66,7 +66,7 @@ struct ParserExtensionPlanResult { // NOLINT: work-around bug in clang-tidy
 	//! Parameters to the function
 	vector<Value> parameters;
 	//! The set of databases that will be modified by this statement (empty for a read-only statement)
-	unordered_set<string> modified_databases;
+	unordered_map<string, StatementProperties::CatalogIdentity> modified_databases;
 	//! Whether or not the statement requires a valid transaction to be executed
 	bool requires_valid_transaction = true;
 	//! What type of result set the statement returns

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

@@ -33,9 +33,7 @@ public:
 	idx_t stmt_location = 0;
 	//! The statement length within the query string
 	idx_t stmt_length = 0;
-	//! The number of prepared statement parameters (if any)
-	idx_t n_param = 0;
-	//! The map of named parameter to param index (if n_param and any named)
+	//! The map of named parameter to param index
 	case_insensitive_map_t<idx_t> named_param_map;
 	//! The query text that corresponds to this SQL statement
 	string query;

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

@@ -14,6 +14,8 @@
 
 namespace duckdb {
 
+enum class CopyToType : uint8_t { COPY_TO_FILE, EXPORT_DATABASE };
+
 class CopyStatement : public SQLStatement {
 public:
 	static constexpr const StatementType TYPE = StatementType::COPY_STATEMENT;

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/sql_statement.hpp"
+#include "duckdb/common/enums/explain_format.hpp"
 
 namespace duckdb {
 
@@ -20,16 +21,19 @@ public:
 	static constexpr const StatementType TYPE = StatementType::EXPLAIN_STATEMENT;
 
 public:
-	explicit ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type = ExplainType::EXPLAIN_STANDARD);
+	explicit ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type = ExplainType::EXPLAIN_STANDARD,
+	                          ExplainFormat explain_format = ExplainFormat::DEFAULT);
 
 	unique_ptr<SQLStatement> stmt;
 	ExplainType explain_type;
+	ExplainFormat explain_format = ExplainFormat::DEFAULT;
 
 protected:
 	ExplainStatement(const ExplainStatement &other);
 
 public:
 	unique_ptr<SQLStatement> Copy() const override;
+	string OptionsToString() const;
 	string ToString() const override;
 };
 

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

@@ -21,7 +21,7 @@ public:
 	static constexpr const StatementType TYPE = StatementType::SET_STATEMENT;
 
 protected:
-	SetStatement(std::string name_p, SetScope scope_p, SetType type_p);
+	SetStatement(string name_p, SetScope scope_p, SetType type_p);
 	SetStatement(const SetStatement &other) = default;
 
 public:
@@ -32,7 +32,7 @@ public:
 
 class SetVariableStatement : public SetStatement {
 public:
-	SetVariableStatement(std::string name_p, unique_ptr<ParsedExpression> value_p, SetScope scope_p);
+	SetVariableStatement(string name_p, unique_ptr<ParsedExpression> value_p, SetScope scope_p);
 
 protected:
 	SetVariableStatement(const SetVariableStatement &other);

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

@@ -18,7 +18,7 @@ public:
 	static constexpr const StatementType TYPE = StatementType::TRANSACTION_STATEMENT;
 
 public:
-	explicit TransactionStatement(TransactionType type);
+	explicit TransactionStatement(unique_ptr<TransactionInfo> info);
 
 	unique_ptr<TransactionInfo> info;
 

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

@@ -28,8 +28,6 @@ public:
 	string schema_name;
 	//! Table name
 	string table_name;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
 
 public:
 	string ToString() const override;

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

@@ -13,25 +13,26 @@
 #include "duckdb/common/types/column/column_data_collection.hpp"
 
 namespace duckdb {
+
 //! Represents a TableReference to a materialized result
 class ColumnDataRef : public TableRef {
 public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::COLUMN_DATA;
 
 public:
-	explicit ColumnDataRef(ColumnDataCollection &collection)
-	    : TableRef(TableReferenceType::COLUMN_DATA), collection(collection) {
+	explicit ColumnDataRef(shared_ptr<ColumnDataCollection> collection)
+	    : TableRef(TableReferenceType::COLUMN_DATA), collection(std::move(collection)) {
 	}
-	ColumnDataRef(vector<string> expected_names, optionally_owned_ptr<ColumnDataCollection> collection_p)
-	    : TableRef(TableReferenceType::COLUMN_DATA), collection(std::move(collection_p)),
-	      expected_names(std::move(expected_names)) {
+	ColumnDataRef(shared_ptr<ColumnDataCollection> collection, vector<string> expected_names)
+	    : TableRef(TableReferenceType::COLUMN_DATA), expected_names(std::move(expected_names)),
+	      collection(std::move(collection)) {
 	}
 
 public:
-	//! (optionally owned) materialized column data
-	optionally_owned_ptr<ColumnDataCollection> collection;
 	//! The set of expected names
 	vector<string> expected_names;
+	//! The collection to scan
+	shared_ptr<ColumnDataCollection> collection;
 
 public:
 	string ToString() const override;
@@ -43,4 +44,5 @@ public:
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<TableRef> Deserialize(Deserializer &source);
 };
+
 } // namespace duckdb

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

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/delimgetref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/tableref.hpp"
+
+namespace duckdb {
+
+class DelimGetRef : public TableRef {
+
+public:
+	explicit DelimGetRef(const vector<LogicalType> &types_p) : TableRef(TableReferenceType::DELIM_GET), types(types_p) {
+		for (idx_t i = 0; i < types.size(); i++) {
+			string column_name = "__internal_delim_get_" + std::to_string(i);
+			internal_aliases.emplace_back(column_name);
+		}
+	}
+
+	vector<string> internal_aliases;
+	vector<LogicalType> types;
+
+public:
+	string ToString() const override;
+	bool Equals(const TableRef &other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb

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

@@ -39,6 +39,10 @@ public:
 	JoinRefType ref_type;
 	//! The set of USING columns (if any)
 	vector<string> using_columns;
+	//! Duplicate eliminated columns (if any)
+	vector<unique_ptr<ParsedExpression>> duplicate_eliminated_columns;
+	//! If we have duplicate eliminated columns if the delim is flipped
+	bool delim_flipped = false;
 
 public:
 	string ToString() const override;

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

@@ -72,8 +72,6 @@ public:
 	vector<PivotColumn> pivots;
 	//! The groups to pivot over. If none are specified all columns not included in the pivots/aggregate are chosen.
 	vector<string> groups;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
 	//! Whether or not to include nulls in the result (UNPIVOT only)
 	bool include_nulls;
 	//! The set of values to pivot on (bound pivot only)

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

@@ -25,8 +25,6 @@ public:
 
 	//! The subquery
 	unique_ptr<SelectStatement> subquery;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
 
 public:
 	string ToString() const override;

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

@@ -23,7 +23,6 @@ public:
 	DUCKDB_API TableFunctionRef();
 
 	unique_ptr<ParsedExpression> function;
-	vector<string> column_name_alias;
 
 	// if the function takes a subquery as argument its in here
 	unique_ptr<SelectStatement> subquery;

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

@@ -33,8 +33,10 @@ public:
 	unique_ptr<SampleOptions> sample;
 	//! The location in the query (if any)
 	optional_idx query_location;
-	// External dependencies of this table function
+	//! External dependencies of this table function
 	shared_ptr<ExternalDependency> external_dependency;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
 
 public:
 	//! Convert the object to a string

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

@@ -36,6 +36,7 @@ struct CommonTableExpressionInfo;
 struct GroupingExpressionMap;
 class OnConflictInfo;
 class UpdateSetInfo;
+class MacroFunction;
 struct ParserOptions;
 struct PivotColumn;
 struct PivotColumnEntry;
@@ -89,6 +90,7 @@ private:
 	Transformer &RootTransformer();
 	const Transformer &RootTransformer() const;
 	void SetParamCount(idx_t new_count);
+	void ClearParameters();
 	void SetParam(const string &name, idx_t index, PreparedParamType type);
 	bool GetParam(const string &name, idx_t &index, PreparedParamType type);
 
@@ -110,9 +112,8 @@ private:
 	// Statement transformation
 	//===--------------------------------------------------------------------===//
 	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a SelectStatement
-	unique_ptr<SelectStatement> TransformSelect(optional_ptr<duckdb_libpgquery::PGNode> node, bool is_select = true);
-	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a SelectStatement
-	unique_ptr<SelectStatement> TransformSelect(duckdb_libpgquery::PGSelectStmt &select, bool is_select = true);
+	unique_ptr<SelectStatement> TransformSelectStmt(duckdb_libpgquery::PGSelectStmt &select, bool is_select = true);
+	unique_ptr<SelectStatement> TransformSelectStmt(duckdb_libpgquery::PGNode &node, bool is_select = true);
 	//! Transform a Postgres T_AlterStmt node into a AlterStatement
 	unique_ptr<AlterStatement> TransformAlter(duckdb_libpgquery::PGAlterTableStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGRenameStmt node into a RenameStatement
@@ -168,8 +169,10 @@ private:
 	unique_ptr<PragmaStatement> TransformImport(duckdb_libpgquery::PGImportStmt &stmt);
 	unique_ptr<ExplainStatement> TransformExplain(duckdb_libpgquery::PGExplainStmt &stmt);
 	unique_ptr<SQLStatement> TransformVacuum(duckdb_libpgquery::PGVacuumStmt &stmt);
-	unique_ptr<SelectStatement> TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt);
-	unique_ptr<SelectStatement> TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt);
+	unique_ptr<QueryNode> TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt);
+	unique_ptr<SelectStatement> TransformShowStmt(duckdb_libpgquery::PGVariableShowStmt &stmt);
+	unique_ptr<QueryNode> TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt);
+	unique_ptr<SelectStatement> TransformShowSelectStmt(duckdb_libpgquery::PGVariableShowSelectStmt &stmt);
 	unique_ptr<AttachStatement> TransformAttach(duckdb_libpgquery::PGAttachStmt &stmt);
 	unique_ptr<DetachStatement> TransformDetach(duckdb_libpgquery::PGDetachStmt &stmt);
 	unique_ptr<SetStatement> TransformUse(duckdb_libpgquery::PGUseStmt &stmt);
@@ -202,7 +205,8 @@ private:
 	// Query Node Transform
 	//===--------------------------------------------------------------------===//
 	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a QueryNode
-	unique_ptr<QueryNode> TransformSelectNode(duckdb_libpgquery::PGSelectStmt &select);
+	unique_ptr<QueryNode> TransformSelectNode(duckdb_libpgquery::PGNode &select, bool is_select = true);
+	unique_ptr<QueryNode> TransformSelectNodeInternal(duckdb_libpgquery::PGSelectStmt &select, bool is_select = true);
 	unique_ptr<QueryNode> TransformSelectInternal(duckdb_libpgquery::PGSelectStmt &select);
 	void TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, QueryNode &node);
 
@@ -257,9 +261,8 @@ private:
 	//===--------------------------------------------------------------------===//
 	// Constraints transform
 	//===--------------------------------------------------------------------===//
-	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell *cell);
-
-	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell *cell, ColumnDefinition &column,
+	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell &cell);
+	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell &cell, ColumnDefinition &column,
 	                                           idx_t index);
 
 	//===--------------------------------------------------------------------===//
@@ -337,6 +340,9 @@ private:
 	//! Transform a Postgres ORDER BY expression into an OrderByDescription
 	bool TransformOrderBy(duckdb_libpgquery::PGList *order, vector<OrderByNode> &result);
 
+	//! Transform to a IN or NOT IN expression
+	unique_ptr<ParsedExpression> TransformInExpression(const string &name, duckdb_libpgquery::PGAExpr &root);
+
 	//! Transform a Postgres SELECT clause into a list of Expressions
 	void TransformExpressionList(duckdb_libpgquery::PGList &list, vector<unique_ptr<ParsedExpression>> &result);
 
@@ -355,6 +361,8 @@ private:
 	Vector PGListToVector(optional_ptr<duckdb_libpgquery::PGList> column_list, idx_t &size);
 	vector<string> TransformConflictTarget(duckdb_libpgquery::PGList &list);
 
+	unique_ptr<MacroFunction> TransformMacroFunction(duckdb_libpgquery::PGFunctionDefinition &function);
+
 	void ParseGenericOptionListEntry(case_insensitive_map_t<vector<Value>> &result_options, string &name,
 	                                 duckdb_libpgquery::PGNode *arg);
 

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

@@ -11,19 +11,21 @@
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/exception/binder_exception.hpp"
+#include "duckdb/common/reference_map.hpp"
+#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/parser/query_node.hpp"
 #include "duckdb/parser/result_modifier.hpp"
+#include "duckdb/parser/tableref/delimgetref.hpp"
 #include "duckdb/parser/tokens.hpp"
 #include "duckdb/planner/bind_context.hpp"
 #include "duckdb/planner/bound_statement.hpp"
 #include "duckdb/planner/bound_tokens.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/joinside.hpp"
-#include "duckdb/common/reference_map.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/planner/tableref/bound_delimgetref.hpp"
 
 namespace duckdb {
 class BoundResultModifier;
@@ -55,7 +57,7 @@ struct BoundLimitNode;
 struct PivotColumnEntry;
 struct UnpivotEntry;
 
-enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES };
+enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES, EXTRACT_REPLACEMENT_SCANS };
 enum class BinderType : uint8_t { REGULAR_BINDER, VIEW_BINDER };
 
 struct CorrelatedColumnInfo {
@@ -196,7 +198,9 @@ public:
 	void SetBindingMode(BindingMode mode);
 	BindingMode GetBindingMode();
 	void AddTableName(string table_name);
+	void AddReplacementScan(const string &table_name, unique_ptr<TableRef> replacement);
 	const unordered_set<string> &GetTableNames();
+	case_insensitive_map_t<unique_ptr<TableRef>> &GetReplacementScans();
 	optional_ptr<SQLStatement> GetRootStatement() {
 		return root_statement;
 	}
@@ -227,6 +231,8 @@ private:
 	BindingMode mode = BindingMode::STANDARD_BINDING;
 	//! Table names extracted for BindingMode::EXTRACT_NAMES
 	unordered_set<string> table_names;
+	//! Replacement Scans extracted for BindingMode::EXTRACT_REPLACEMENT_SCANS
+	case_insensitive_map_t<unique_ptr<TableRef>> replacement_scans;
 	//! The set of bound views
 	reference_set_t<ViewCatalogEntry> bound_views;
 	//! Used to retrieve CatalogEntry's
@@ -253,14 +259,13 @@ private:
 	void MoveCorrelatedExpressions(Binder &other);
 
 	//! Tries to bind the table name with replacement scans
-	unique_ptr<BoundTableRef> BindWithReplacementScan(ClientContext &context, const string &table_name,
-	                                                  BaseTableRef &ref);
+	unique_ptr<BoundTableRef> BindWithReplacementScan(ClientContext &context, BaseTableRef &ref);
 
 	template <class T>
 	BoundStatement BindWithCTE(T &statement);
 	BoundStatement Bind(SelectStatement &stmt);
 	BoundStatement Bind(InsertStatement &stmt);
-	BoundStatement Bind(CopyStatement &stmt);
+	BoundStatement Bind(CopyStatement &stmt, CopyToType copy_to_type);
 	BoundStatement Bind(DeleteStatement &stmt);
 	BoundStatement Bind(UpdateStatement &stmt);
 	BoundStatement Bind(CreateStatement &stmt);
@@ -294,6 +299,9 @@ private:
 
 	unique_ptr<BoundCTENode> BindMaterializedCTE(CommonTableExpressionMap &cte_map);
 	unique_ptr<BoundCTENode> BindCTE(CTENode &statement);
+	//! Materializes CTEs if this is expected to improve performance
+	bool OptimizeCTEs(QueryNode &node);
+
 	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
 	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);
 	unique_ptr<BoundQueryNode> BindNode(RecursiveCTENode &node);
@@ -314,6 +322,7 @@ private:
 	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, optional_ptr<CommonTableExpressionInfo> cte = nullptr);
 	unique_ptr<BoundTableRef> Bind(TableFunctionRef &ref);
 	unique_ptr<BoundTableRef> Bind(EmptyTableRef &ref);
+	unique_ptr<BoundTableRef> Bind(DelimGetRef &ref);
 	unique_ptr<BoundTableRef> Bind(ExpressionListRef &ref);
 	unique_ptr<BoundTableRef> Bind(ColumnDataRef &ref);
 	unique_ptr<BoundTableRef> Bind(PivotRef &expr);
@@ -331,8 +340,8 @@ private:
 	                                 vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
 	                                 vector<Value> &parameters, named_parameter_map_t &named_parameters,
 	                                 unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error);
-	bool BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
-	                                 unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error);
+	void BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
+	                                 unique_ptr<BoundSubqueryRef> &subquery);
 	unique_ptr<LogicalOperator> BindTableFunction(TableFunction &function, vector<Value> parameters);
 	unique_ptr<LogicalOperator> BindTableFunctionInternal(TableFunction &table_function, const TableFunctionRef &ref,
 	                                                      vector<Value> parameters,
@@ -349,8 +358,9 @@ private:
 	unique_ptr<LogicalOperator> CreatePlan(BoundColumnDataRef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundCTERef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundPivotRef &ref);
+	unique_ptr<LogicalOperator> CreatePlan(BoundDelimGetRef &ref);
 
-	BoundStatement BindCopyTo(CopyStatement &stmt);
+	BoundStatement BindCopyTo(CopyStatement &stmt, CopyToType copy_to_type);
 	BoundStatement BindCopyFrom(CopyStatement &stmt);
 
 	void PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result);
@@ -387,6 +397,8 @@ private:
 	                           vector<unique_ptr<ParsedExpression>> &new_select_list);
 	void ExpandStarExpression(unique_ptr<ParsedExpression> expr, vector<unique_ptr<ParsedExpression>> &new_select_list);
 	bool FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpression **star, bool is_root, bool in_columns);
+	void ReplaceUnpackedStarExpression(unique_ptr<ParsedExpression> &expr,
+	                                   vector<unique_ptr<ParsedExpression>> &replacements);
 	void ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement);
 	void BindWhereStarExpression(unique_ptr<ParsedExpression> &expr);
 
@@ -404,10 +416,8 @@ private:
 	unique_ptr<BoundTableRef> BindShowTable(ShowRef &ref);
 	unique_ptr<BoundTableRef> BindSummarize(ShowRef &ref);
 
-public:
-	// This should really be a private constructor, but make_shared_ptr does not allow it...
-	// If you are thinking about calling this, you should probably call Binder::CreateBinder
-	Binder(bool i_know_what_i_am_doing, ClientContext &context, shared_ptr<Binder> parent, BinderType binder_type);
+private:
+	Binder(ClientContext &context, shared_ptr<Binder> parent, BinderType binder_type);
 };
 
 } // namespace duckdb