duckdb 0.7.2-dev1901.0 → 0.7.2-dev2233.0

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

@@ -11,18 +11,20 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/exception_format_value.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class SQLStatement;
 
 class QueryErrorContext {
 public:
-	explicit QueryErrorContext(SQLStatement *statement_ = nullptr, idx_t query_location_ = DConstants::INVALID_INDEX)
+	explicit QueryErrorContext(optional_ptr<SQLStatement> statement_ = nullptr,
+	                           idx_t query_location_ = DConstants::INVALID_INDEX)
 	    : statement(statement_), query_location(query_location_) {
 	}
 
 	//! The query statement
-	SQLStatement *statement;
+	optional_ptr<SQLStatement> statement;
 	//! The location in which the error should be thrown
 	idx_t query_location;
 

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

@@ -49,19 +49,17 @@ class Transformer {
 
 public:
 	explicit Transformer(ParserOptions &options);
-	explicit Transformer(Transformer *parent);
+	explicit Transformer(Transformer &parent);
 	~Transformer();
 
 	//! Transforms a Postgres parse tree into a set of SQL Statements
 	bool TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements);
 	string NodetypeToString(duckdb_libpgquery::PGNodeTag type);
 
-	idx_t ParamCount() {
-		return parent ? parent->ParamCount() : prepared_statement_parameter_index;
-	}
+	idx_t ParamCount() const;
 
 private:
-	Transformer *parent;
+	optional_ptr<Transformer> parent;
 	//! Parser options
 	ParserOptions &options;
 	//! The current prepared statement parameter index
@@ -80,36 +78,12 @@ private:
 	void Clear();
 	bool InWindowDefinition();
 
-	void SetParamCount(idx_t new_count) {
-		if (parent) {
-			parent->SetParamCount(new_count);
-		} else {
-			this->prepared_statement_parameter_index = new_count;
-		}
-	}
-	void SetNamedParam(const string &name, int32_t index) {
-		if (parent) {
-			parent->SetNamedParam(name, index);
-		} else {
-			D_ASSERT(!named_param_map.count(name));
-			this->named_param_map[name] = index;
-		}
-	}
-	bool GetNamedParam(const string &name, int32_t &index) {
-		if (parent) {
-			return parent->GetNamedParam(name, index);
-		} else {
-			auto entry = named_param_map.find(name);
-			if (entry == named_param_map.end()) {
-				return false;
-			}
-			index = entry->second;
-			return true;
-		}
-	}
-	bool HasNamedParameters() const {
-		return parent ? parent->HasNamedParameters() : !named_param_map.empty();
-	}
+	Transformer &RootTransformer();
+	const Transformer &RootTransformer() const;
+	void SetParamCount(idx_t new_count);
+	void SetNamedParam(const string &name, int32_t index);
+	bool GetNamedParam(const string &name, int32_t &index);
+	bool HasNamedParameters() const;
 
 	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column);
 	unique_ptr<SQLStatement> GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry);

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

@@ -21,6 +21,7 @@
 #include "duckdb/planner/bound_tokens.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/common/reference_map.hpp"
 
 namespace duckdb {
 class BoundResultModifier;
@@ -76,43 +77,43 @@ class Binder : public std::enable_shared_from_this<Binder> {
 	friend class RecursiveSubqueryPlanner;
 
 public:
-	DUCKDB_API static shared_ptr<Binder> CreateBinder(ClientContext &context, Binder *parent = nullptr,
+	DUCKDB_API static shared_ptr<Binder> CreateBinder(ClientContext &context, optional_ptr<Binder> parent = nullptr,
 	                                                  bool inherit_ctes = true);
 
 	//! The client context
 	ClientContext &context;
 	//! A mapping of names to common table expressions
-	case_insensitive_map_t<CommonTableExpressionInfo *> CTE_bindings; // NOLINT
+	case_insensitive_map_t<reference<CommonTableExpressionInfo>> CTE_bindings; // NOLINT
 	//! The CTEs that have already been bound
-	unordered_set<CommonTableExpressionInfo *> bound_ctes;
+	reference_set_t<CommonTableExpressionInfo> bound_ctes;
 	//! The bind context
 	BindContext bind_context;
 	//! The set of correlated columns bound by this binder (FIXME: this should probably be an unordered_set and not a
 	//! vector)
 	vector<CorrelatedColumnInfo> correlated_columns;
 	//! The set of parameter expressions bound by this binder
-	BoundParameterMap *parameters;
+	optional_ptr<BoundParameterMap> parameters;
 	//! Statement properties
 	StatementProperties properties;
 	//! The alias for the currently processing subquery, if it exists
 	string alias;
 	//! Macro parameter bindings (if any)
-	DummyBinding *macro_binding = nullptr;
+	optional_ptr<DummyBinding> macro_binding;
 	//! The intermediate lambda bindings to bind nested lambdas (if any)
-	vector<DummyBinding> *lambda_bindings = nullptr;
+	optional_ptr<vector<DummyBinding>> lambda_bindings;
 
 public:
 	DUCKDB_API BoundStatement Bind(SQLStatement &statement);
 	DUCKDB_API BoundStatement Bind(QueryNode &node);
 
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info);
-	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema);
+	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema);
 
 	vector<unique_ptr<Expression>> BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info);
 
 	void BindCreateViewInfo(CreateViewInfo &base);
-	SchemaCatalogEntry *BindSchema(CreateInfo &info);
-	SchemaCatalogEntry *BindCreateFunctionInfo(CreateInfo &info);
+	SchemaCatalogEntry &BindSchema(CreateInfo &info);
+	SchemaCatalogEntry &BindCreateFunctionInfo(CreateInfo &info);
 
 	//! Check usage, and cast named parameters to their types
 	static void BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
@@ -125,22 +126,22 @@ public:
 	idx_t GenerateTableIndex();
 
 	//! Add a common table expression to the binder
-	void AddCTE(const string &name, CommonTableExpressionInfo *cte);
+	void AddCTE(const string &name, CommonTableExpressionInfo &cte);
 	//! Find a common table expression by name; returns nullptr if none exists
-	CommonTableExpressionInfo *FindCTE(const string &name, bool skip = false);
+	optional_ptr<CommonTableExpressionInfo> FindCTE(const string &name, bool skip = false);
 
-	bool CTEIsAlreadyBound(CommonTableExpressionInfo *cte);
+	bool CTEIsAlreadyBound(CommonTableExpressionInfo &cte);
 
 	//! Add the view to the set of currently bound views - used for detecting recursive view definitions
-	void AddBoundView(ViewCatalogEntry *view);
+	void AddBoundView(ViewCatalogEntry &view);
 
-	void PushExpressionBinder(ExpressionBinder *binder);
+	void PushExpressionBinder(ExpressionBinder &binder);
 	void PopExpressionBinder();
-	void SetActiveBinder(ExpressionBinder *binder);
-	ExpressionBinder *GetActiveBinder();
+	void SetActiveBinder(ExpressionBinder &binder);
+	ExpressionBinder &GetActiveBinder();
 	bool HasActiveBinder();
 
-	vector<ExpressionBinder *> &GetActiveBinders();
+	vector<reference<ExpressionBinder>> &GetActiveBinders();
 
 	void MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other);
 	//! Add a correlated column to this binder (if it does not exist)
@@ -184,7 +185,7 @@ public:
 	BindingMode GetBindingMode();
 	void AddTableName(string table_name);
 	const unordered_set<string> &GetTableNames();
-	SQLStatement *GetRootStatement() {
+	optional_ptr<SQLStatement> GetRootStatement() {
 		return root_statement;
 	}
 
@@ -194,7 +195,7 @@ private:
 	//! The parent binder (if any)
 	shared_ptr<Binder> parent;
 	//! The vector of active binders
-	vector<ExpressionBinder *> active_binders;
+	vector<reference<ExpressionBinder>> active_binders;
 	//! The count of bound_tables
 	idx_t bound_tables;
 	//! Whether or not the binder has any unplanned subqueries that still need to be planned
@@ -206,13 +207,13 @@ private:
 	//! Whether or not the binder can contain NULLs as the root of expressions
 	bool can_contain_nulls = false;
 	//! The root statement of the query that is currently being parsed
-	SQLStatement *root_statement = nullptr;
+	optional_ptr<SQLStatement> root_statement;
 	//! Binding mode
 	BindingMode mode = BindingMode::STANDARD_BINDING;
 	//! Table names extracted for BindingMode::EXTRACT_NAMES
 	unordered_set<string> table_names;
 	//! The set of bound views
-	unordered_set<ViewCatalogEntry *> bound_views;
+	reference_set_t<ViewCatalogEntry> bound_views;
 
 private:
 	//! Bind the expressions of generated columns to check for errors
@@ -273,7 +274,7 @@ private:
 
 	unique_ptr<BoundTableRef> Bind(BaseTableRef &ref);
 	unique_ptr<BoundTableRef> Bind(JoinRef &ref);
-	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, CommonTableExpressionInfo *cte = nullptr);
+	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(ExpressionListRef &ref);
@@ -349,7 +350,7 @@ private:
 
 	//! If only a schema name is provided (e.g. "a.b") then figure out if "a" is a schema or a catalog name
 	void BindSchemaOrCatalog(string &catalog_name, string &schema_name);
-	SchemaCatalogEntry *BindCreateSchema(CreateInfo &info);
+	SchemaCatalogEntry &BindCreateSchema(CreateInfo &info);
 
 	unique_ptr<BoundQueryNode> BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);
 

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

@@ -59,8 +59,8 @@ public:
 	//! be added. Defaults to INVALID.
 	LogicalType target_type;
 
-	DummyBinding *macro_binding;
-	vector<DummyBinding> *lambda_bindings = nullptr;
+	optional_ptr<DummyBinding> macro_binding;
+	optional_ptr<vector<DummyBinding>> lambda_bindings;
 
 public:
 	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> &expr, LogicalType *result_type = nullptr,
@@ -146,7 +146,7 @@ protected:
 
 	Binder &binder;
 	ClientContext &context;
-	ExpressionBinder *stored_binder;
+	optional_ptr<ExpressionBinder> stored_binder;
 	vector<BoundColumnReferenceInfo> bound_columns;
 };
 

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

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 
 namespace duckdb {

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/function/copy_function.hpp"
+#include "duckdb/common/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
 
 namespace duckdb {
@@ -27,7 +28,8 @@ public:
 	unique_ptr<FunctionData> bind_data;
 	std::string file_path;
 	bool use_tmp_file;
-	bool allow_overwrite;
+	FilenamePattern filename_pattern;
+	bool overwrite_or_ignore;
 	bool per_thread_output;
 
 	bool partition_output;

package/src/duckdb/src/include/duckdb/storage/table/table_index_list.hpp

@@ -35,7 +35,7 @@ public:
 
 	void AddIndex(unique_ptr<Index> index);
 
-	void RemoveIndex(Index *index);
+	void RemoveIndex(Index &index);
 
 	bool Empty();
 

package/src/duckdb/src/main/appender.cpp

@@ -3,15 +3,15 @@
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/main/connection.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/operator/decimal_cast_operators.hpp"
+#include "duckdb/common/operator/string_cast.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/main/connection.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/storage/data_table.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/string_cast.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
 
 namespace duckdb {
 

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

@@ -10,7 +10,7 @@
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/common/serializer/buffered_file_writer.hpp"
 #include "duckdb/common/serializer/buffered_serializer.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/column_binding_resolver.hpp"
 #include "duckdb/execution/operator/helper/physical_result_collector.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"

package/src/duckdb/src/main/connection.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/main/connection.hpp"
 
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
+#include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/main/appender.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/connection_manager.hpp"
@@ -14,8 +16,6 @@
 #include "duckdb/main/relation/view_relation.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
-#include "duckdb/function/table/read_csv.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/main/query_result.cpp

@@ -58,6 +58,19 @@ QueryResult::QueryResult(QueryResultType type, StatementType statement_type, Sta
       client_properties(std::move(client_properties_p)) {
 }
 
+bool CurrentChunk::Valid() {
+	if (data_chunk) {
+		if (position < data_chunk->size()) {
+			return true;
+		}
+	}
+	return false;
+}
+
+idx_t CurrentChunk::RemainingSize() {
+	return data_chunk->size() - position;
+}
+
 QueryResult::QueryResult(QueryResultType type, PreservedError error) : BaseQueryResult(type, std::move(error)) {
 }
 

package/src/duckdb/src/main/settings/settings.cpp

@@ -512,16 +512,15 @@ Value EnableProgressBarPrintSetting::GetSetting(ClientContext &context) {
 // Experimental Parallel CSV
 //===--------------------------------------------------------------------===//
 void ExperimentalParallelCSVSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.experimental_parallel_csv_reader = input.GetValue<bool>();
+	Printer::Print("experimental_parallel_csv is deprecated and will be removed with the next release - the parallel "
+	               "CSV reader is now standard and does not need to be manually enabled anymore 1");
 }
 
 void ExperimentalParallelCSVSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.experimental_parallel_csv_reader = DBConfig().options.experimental_parallel_csv_reader;
 }
 
 Value ExperimentalParallelCSVSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BIGINT(config.options.experimental_parallel_csv_reader);
+	return Value();
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/optimizer/expression_rewriter.cpp

@@ -9,14 +9,14 @@
 
 namespace duckdb {
 
-unique_ptr<Expression> ExpressionRewriter::ApplyRules(LogicalOperator &op, const vector<Rule *> &rules,
+unique_ptr<Expression> ExpressionRewriter::ApplyRules(LogicalOperator &op, const vector<reference<Rule>> &rules,
                                                       unique_ptr<Expression> expr, bool &changes_made, bool is_root) {
 	for (auto &rule : rules) {
 		vector<reference<Expression>> bindings;
-		if (rule->root->Match(*expr, bindings)) {
+		if (rule.get().root->Match(*expr, bindings)) {
 			// the rule matches! try to apply it
 			bool rule_made_change = false;
-			auto result = rule->Apply(op, bindings, rule_made_change, is_root);
+			auto result = rule.get().Apply(op, bindings, rule_made_change, is_root);
 			if (result) {
 				changes_made = true;
 				// the base node changed: the rule applied changes
@@ -63,7 +63,7 @@ void ExpressionRewriter::VisitOperator(LogicalOperator &op) {
 			// this rule does not apply to this type of LogicalOperator
 			continue;
 		}
-		to_apply_rules.push_back(rule.get());
+		to_apply_rules.push_back(*rule);
 	}
 	if (to_apply_rules.empty()) {
 		// no rules to apply on this node