duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/parallel/pipeline.cpp

@@ -15,54 +15,54 @@
 
 namespace duckdb {
 
-class PipelineTask : public ExecutorTask {
-	static constexpr const idx_t PARTIAL_CHUNK_COUNT = 50;
+PipelineTask::PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
+    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) {
+}
+
+bool PipelineTask::TaskBlockedOnResult() const {
+	// If this returns true, it means the pipeline this task belongs to has a cached chunk
+	// that was the result of the Sink method returning BLOCKED
+	return pipeline_executor->RemainingSinkChunk();
+}
+
+const PipelineExecutor &PipelineTask::GetPipelineExecutor() const {
+	return *pipeline_executor;
+}
 
-public:
-	explicit PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
-	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) {
+TaskExecutionResult PipelineTask::ExecuteTask(TaskExecutionMode mode) {
+	if (!pipeline_executor) {
+		pipeline_executor = make_uniq<PipelineExecutor>(pipeline.GetClientContext(), pipeline);
 	}
 
-	Pipeline &pipeline;
-	shared_ptr<Event> event;
-	unique_ptr<PipelineExecutor> pipeline_executor;
+	pipeline_executor->SetTaskForInterrupts(shared_from_this());
 
-public:
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		if (!pipeline_executor) {
-			pipeline_executor = make_uniq<PipelineExecutor>(pipeline.GetClientContext(), pipeline);
-		}
+	if (mode == TaskExecutionMode::PROCESS_PARTIAL) {
+		auto res = pipeline_executor->Execute(PARTIAL_CHUNK_COUNT);
 
-		pipeline_executor->SetTaskForInterrupts(shared_from_this());
-
-		if (mode == TaskExecutionMode::PROCESS_PARTIAL) {
-			auto res = pipeline_executor->Execute(PARTIAL_CHUNK_COUNT);
-
-			switch (res) {
-			case PipelineExecuteResult::NOT_FINISHED:
-				return TaskExecutionResult::TASK_NOT_FINISHED;
-			case PipelineExecuteResult::INTERRUPTED:
-				return TaskExecutionResult::TASK_BLOCKED;
-			case PipelineExecuteResult::FINISHED:
-				break;
-			}
-		} else {
-			auto res = pipeline_executor->Execute();
-			switch (res) {
-			case PipelineExecuteResult::NOT_FINISHED:
-				throw InternalException("Execute without limit should not return NOT_FINISHED");
-			case PipelineExecuteResult::INTERRUPTED:
-				return TaskExecutionResult::TASK_BLOCKED;
-			case PipelineExecuteResult::FINISHED:
-				break;
-			}
+		switch (res) {
+		case PipelineExecuteResult::NOT_FINISHED:
+			return TaskExecutionResult::TASK_NOT_FINISHED;
+		case PipelineExecuteResult::INTERRUPTED:
+			return TaskExecutionResult::TASK_BLOCKED;
+		case PipelineExecuteResult::FINISHED:
+			break;
+		}
+	} else {
+		auto res = pipeline_executor->Execute();
+		switch (res) {
+		case PipelineExecuteResult::NOT_FINISHED:
+			throw InternalException("Execute without limit should not return NOT_FINISHED");
+		case PipelineExecuteResult::INTERRUPTED:
+			return TaskExecutionResult::TASK_BLOCKED;
+		case PipelineExecuteResult::FINISHED:
+			break;
 		}
-
-		event->FinishTask();
-		pipeline_executor.reset();
-		return TaskExecutionResult::TASK_FINISHED;
 	}
-};
+
+	event->FinishTask();
+	pipeline_executor.reset();
+	return TaskExecutionResult::TASK_FINISHED;
+}
 
 Pipeline::Pipeline(Executor &executor_p)
     : executor(executor_p), ready(false), initialized(false), source(nullptr), sink(nullptr) {

package/src/duckdb/src/parallel/pipeline_event.cpp

@@ -12,12 +12,10 @@ void PipelineEvent::Schedule() {
 	try {
 		pipeline->Schedule(event);
 		D_ASSERT(total_tasks > 0);
-	} catch (Exception &ex) {
-		executor.PushError(PreservedError(ex));
 	} catch (std::exception &ex) {
-		executor.PushError(PreservedError(ex));
+		executor.PushError(ErrorData(ex));
 	} catch (...) { // LCOV_EXCL_START
-		executor.PushError(PreservedError("Unknown exception in Finalize!"));
+		executor.PushError(ErrorData("Unknown exception in Finalize!"));
 	} // LCOV_EXCL_STOP
 }
 

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -109,13 +109,19 @@ bool PipelineExecutor::TryFlushCachingOperators() {
 SinkNextBatchType PipelineExecutor::NextBatch(duckdb::DataChunk &source_chunk) {
 	D_ASSERT(requires_batch_index);
 	idx_t next_batch_index;
+	auto max_batch_index = pipeline.base_batch_index + PipelineBuildState::BATCH_INCREMENT - 1;
 	if (source_chunk.size() == 0) {
-		next_batch_index = NumericLimits<int64_t>::Maximum();
+		// set it to the maximum valid batch index value for the current pipeline
+		next_batch_index = max_batch_index;
 	} else {
-		next_batch_index =
+		auto batch_index =
 		    pipeline.source->GetBatchIndex(context, source_chunk, *pipeline.source_state, *local_source_state);
 		// we start with the base_batch_index as a valid starting value. Make sure that next batch is called below
-		next_batch_index += pipeline.base_batch_index + 1;
+		next_batch_index = pipeline.base_batch_index + batch_index + 1;
+		if (next_batch_index >= max_batch_index) {
+			throw InternalException("Pipeline batch index - invalid batch index %llu returned by source operator",
+			                        batch_index);
+		}
 	}
 	auto &partition_info = local_sink_state->partition_info;
 	if (next_batch_index == partition_info.batch_index.GetIndex()) {
@@ -239,6 +245,10 @@ PipelineExecuteResult PipelineExecutor::Execute(idx_t max_chunks) {
 	return PushFinalize();
 }
 
+bool PipelineExecutor::RemainingSinkChunk() const {
+	return remaining_sink_chunk;
+}
+
 PipelineExecuteResult PipelineExecutor::Execute() {
 	return Execute(NumericLimits<idx_t>::Maximum());
 }
@@ -342,78 +352,6 @@ PipelineExecuteResult PipelineExecutor::PushFinalize() {
 	return PipelineExecuteResult::FINISHED;
 }
 
-// TODO: Refactoring the StreamingQueryResult to use Push-based execution should eliminate the need for this code
-void PipelineExecutor::ExecutePull(DataChunk &result) {
-	if (IsFinished()) {
-		return;
-	}
-	auto &executor = pipeline.executor;
-	try {
-		D_ASSERT(!pipeline.sink);
-		D_ASSERT(!requires_batch_index);
-		auto &source_chunk = pipeline.operators.empty() ? result : *intermediate_chunks[0];
-		while (result.size() == 0 && (!exhausted_source || !in_process_operators.empty())) {
-			if (in_process_operators.empty()) {
-				source_chunk.Reset();
-
-				auto done_signal = make_shared<InterruptDoneSignalState>();
-				interrupt_state = InterruptState(done_signal);
-				SourceResultType source_result;
-
-				// Repeatedly try to fetch from the source until it doesn't block. Note that it may block multiple times
-				while (true) {
-					D_ASSERT(!exhausted_source);
-					source_result = FetchFromSource(source_chunk);
-
-					// No interrupt happened, all good.
-					if (source_result != SourceResultType::BLOCKED) {
-						break;
-					}
-
-					// Busy wait for async callback from source operator
-					done_signal->Await();
-				}
-
-				if (source_result == SourceResultType::FINISHED) {
-					exhausted_source = true;
-					if (source_chunk.size() == 0) {
-						break;
-					}
-				}
-			}
-			if (!pipeline.operators.empty()) {
-				auto state = Execute(source_chunk, result);
-				if (state == OperatorResultType::FINISHED) {
-					break;
-				}
-			}
-		}
-	} catch (const Exception &ex) { // LCOV_EXCL_START
-		if (executor.HasError()) {
-			executor.ThrowException();
-		}
-		throw;
-	} catch (std::exception &ex) {
-		if (executor.HasError()) {
-			executor.ThrowException();
-		}
-		throw;
-	} catch (...) {
-		if (executor.HasError()) {
-			executor.ThrowException();
-		}
-		throw;
-	} // LCOV_EXCL_STOP
-}
-
-void PipelineExecutor::PullFinalize() {
-	if (finalized) {
-		throw InternalException("Calling PullFinalize on a pipeline that has been finalized already");
-	}
-	finalized = true;
-	pipeline.executor.Flush(thread);
-}
-
 void PipelineExecutor::GoToSource(idx_t &current_idx, idx_t initial_idx) {
 	// we go back to the first operator (the source)
 	current_idx = initial_idx;

package/src/duckdb/src/parallel/task_scheduler.cpp

@@ -97,12 +97,12 @@ ProducerToken::~ProducerToken() {
 
 TaskScheduler::TaskScheduler(DatabaseInstance &db)
     : db(db), queue(make_uniq<ConcurrentQueue>()),
-      allocator_flush_threshold(db.config.options.allocator_flush_threshold) {
+      allocator_flush_threshold(db.config.options.allocator_flush_threshold), thread_count(0) {
 }
 
 TaskScheduler::~TaskScheduler() {
 #ifndef DUCKDB_NO_THREADS
-	SetThreadsInternal(1);
+	RelaunchThreadsInternal(0);
 #endif
 }
 
@@ -231,19 +231,22 @@ static void ThreadExecuteTasks(TaskScheduler *scheduler, atomic<bool> *marker) {
 int32_t TaskScheduler::NumberOfThreads() {
 	lock_guard<mutex> t(thread_lock);
 	auto &config = DBConfig::GetConfig(db);
-	return threads.size() + config.options.external_threads + 1;
+	return threads.size() + config.options.external_threads;
 }
 
-void TaskScheduler::SetThreads(int32_t n) {
+void TaskScheduler::SetThreads(idx_t total_threads, idx_t external_threads) {
+	if (total_threads == 0) {
+		throw SyntaxException("Number of threads must be positive!");
+	}
 #ifndef DUCKDB_NO_THREADS
-	lock_guard<mutex> t(thread_lock);
-	if (n < 1) {
-		throw SyntaxException("Must have at least 1 thread!");
+	if (total_threads < external_threads) {
+		throw SyntaxException("Number of threads can't be smaller than number of external threads!");
 	}
-	SetThreadsInternal(n);
+	thread_count = total_threads - external_threads;
 #else
-	if (n != 1) {
-		throw NotImplementedException("DuckDB was compiled without threads! Setting threads > 1 is not allowed.");
+	if (threads.size() != external_threads) {
+		throw NotImplementedException(
+		    "DuckDB was compiled without threads! Setting threads != external_threads is not allowed.");
 	}
 #endif
 }
@@ -263,12 +266,18 @@ void TaskScheduler::YieldThread() {
 #endif
 }
 
-void TaskScheduler::SetThreadsInternal(int32_t n) {
+void TaskScheduler::RelaunchThreads() {
+	lock_guard<mutex> t(thread_lock);
+	auto n = thread_count.load();
+	RelaunchThreadsInternal(n);
+}
+
+void TaskScheduler::RelaunchThreadsInternal(int32_t n) {
 #ifndef DUCKDB_NO_THREADS
-	if (threads.size() == idx_t(n - 1)) {
+	idx_t new_thread_count = n;
+	if (threads.size() == new_thread_count) {
 		return;
 	}
-	idx_t new_thread_count = n - 1;
 	if (threads.size() > new_thread_count) {
 		// we are reducing the number of threads: clear all threads first
 		for (idx_t i = 0; i < threads.size(); i++) {

package/src/duckdb/src/parser/column_definition.cpp

@@ -22,14 +22,25 @@ ColumnDefinition ColumnDefinition::Copy() const {
 	copy.expression = expression ? expression->Copy() : nullptr;
 	copy.compression_type = compression_type;
 	copy.category = category;
+	copy.comment = comment;
 	return copy;
 }
 
-const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
+const ParsedExpression &ColumnDefinition::DefaultValue() const {
+	if (!HasDefaultValue()) {
+		if (Generated()) {
+			throw InternalException("Calling DefaultValue() on a generated column");
+		}
+		throw InternalException("DefaultValue() called on a column without a default value");
+	}
+	return *expression;
+}
+
+bool ColumnDefinition::HasDefaultValue() const {
 	if (Generated()) {
-		throw InternalException("Calling DefaultValue() on a generated column");
+		return false;
 	}
-	return expression;
+	return expression != nullptr;
 }
 
 void ColumnDefinition::SetDefaultValue(unique_ptr<ParsedExpression> default_value) {
@@ -54,11 +65,18 @@ void ColumnDefinition::SetType(const LogicalType &type) {
 const string &ColumnDefinition::Name() const {
 	return name;
 }
-
 void ColumnDefinition::SetName(const string &name) {
 	this->name = name;
 }
 
+const Value &ColumnDefinition::Comment() const {
+	return comment;
+}
+
+void ColumnDefinition::SetComment(const Value &comment) {
+	this->comment = comment;
+}
+
 const duckdb::CompressionType &ColumnDefinition::CompressionType() const {
 	return compression_type;
 }

package/src/duckdb/src/parser/column_list.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/parser/column_list.hpp"
 #include "duckdb/common/string.hpp"
 #include "duckdb/common/to_string.hpp"
+#include "duckdb/common/exception/catalog_exception.hpp"
 
 namespace duckdb {
 
@@ -39,7 +40,7 @@ void ColumnList::AddToNameMap(ColumnDefinition &col) {
 		idx_t index = 1;
 		string base_name = col.Name();
 		while (name_map.find(col.Name()) != name_map.end()) {
-			col.SetName(base_name + ":" + to_string(index++));
+			col.SetName(base_name + "_" + to_string(index++));
 		}
 	} else {
 		if (name_map.find(col.Name()) != name_map.end()) {

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

@@ -35,7 +35,7 @@ FunctionExpression::FunctionExpression(const string &function_name, vector<uniqu
 }
 
 string FunctionExpression::ToString() const {
-	return ToString<FunctionExpression, ParsedExpression>(*this, schema, function_name, is_operator, distinct,
+	return ToString<FunctionExpression, ParsedExpression>(*this, catalog, schema, function_name, is_operator, distinct,
 	                                                      filter.get(), order_bys.get(), export_state, true);
 }
 

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

@@ -1,6 +1,8 @@
 #include "duckdb/parser/expression/lambda_expression.hpp"
+
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
@@ -14,6 +16,55 @@ LambdaExpression::LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<
     : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA), lhs(std::move(lhs)), expr(std::move(expr)) {
 }
 
+vector<reference<ParsedExpression>> LambdaExpression::ExtractColumnRefExpressions(string &error_message) {
+
+	// we return an error message because we can't throw a binder exception here,
+	// since we can't distinguish between a lambda function and the JSON operator yet
+	vector<reference<ParsedExpression>> column_refs;
+
+	if (lhs->expression_class == ExpressionClass::COLUMN_REF) {
+		// single column reference
+		column_refs.emplace_back(*lhs);
+		return column_refs;
+	}
+
+	if (lhs->expression_class == ExpressionClass::FUNCTION) {
+		// list of column references
+		auto &func_expr = lhs->Cast<FunctionExpression>();
+		if (func_expr.function_name != "row") {
+			error_message = InvalidParametersErrorMessage();
+			return column_refs;
+		}
+
+		for (auto &child : func_expr.children) {
+			if (child->expression_class != ExpressionClass::COLUMN_REF) {
+				error_message = InvalidParametersErrorMessage();
+				return column_refs;
+			}
+			column_refs.emplace_back(*child);
+		}
+	}
+
+	if (column_refs.empty()) {
+		error_message = InvalidParametersErrorMessage();
+	}
+	return column_refs;
+}
+
+string LambdaExpression::InvalidParametersErrorMessage() {
+	return "Invalid lambda parameters! Parameters must be unqualified comma-separated names like x or (x, y).";
+}
+
+bool LambdaExpression::IsLambdaParameter(const vector<unordered_set<string>> &lambda_params,
+                                         const string &parameter_name) {
+	for (const auto &level : lambda_params) {
+		if (level.find(parameter_name) != level.end()) {
+			return true;
+		}
+	}
+	return false;
+}
+
 string LambdaExpression::ToString() const {
 	return "(" + lhs->ToString() + " -> " + expr->ToString() + ")";
 }

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

@@ -0,0 +1,59 @@
+#include "duckdb/parser/expression/lambdaref_expression.hpp"
+
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/planner/table_binding.hpp"
+
+namespace duckdb {
+
+LambdaRefExpression::LambdaRefExpression(idx_t lambda_idx, string column_name_p)
+    : ParsedExpression(ExpressionType::LAMBDA_REF, ExpressionClass::LAMBDA_REF), lambda_idx(lambda_idx),
+      column_name(std::move(column_name_p)) {
+	alias = column_name;
+}
+
+bool LambdaRefExpression::IsScalar() const {
+	throw InternalException("lambda reference expressions are transient, IsScalar should never be called");
+}
+
+string LambdaRefExpression::GetName() const {
+	return column_name;
+}
+
+string LambdaRefExpression::ToString() const {
+	throw InternalException("lambda reference expressions are transient, ToString should never be called");
+}
+
+hash_t LambdaRefExpression::Hash() const {
+	hash_t result = ParsedExpression::Hash();
+	result = CombineHash(result, lambda_idx);
+	result = CombineHash(result, StringUtil::CIHash(column_name));
+	return result;
+}
+
+unique_ptr<ParsedExpression> LambdaRefExpression::Copy() const {
+	throw InternalException("lambda reference expressions are transient, Copy should never be called");
+}
+
+unique_ptr<ParsedExpression>
+LambdaRefExpression::FindMatchingBinding(optional_ptr<vector<DummyBinding>> &lambda_bindings,
+                                         const string &column_name) {
+
+	// if this is a lambda parameter, then we temporarily add a BoundLambdaRef,
+	// which we capture and remove later
+
+	// inner lambda parameters have precedence over outer lambda parameters, and
+	// lambda parameters have precedence over macros and columns
+
+	if (lambda_bindings) {
+		for (idx_t i = lambda_bindings->size(); i > 0; i--) {
+			if ((*lambda_bindings)[i - 1].HasMatchingBinding(column_name)) {
+				D_ASSERT(!(*lambda_bindings)[i - 1].alias.empty());
+				return make_uniq<LambdaRefExpression>(i - 1, column_name);
+			}
+		}
+	}
+
+	return nullptr;
+}
+
+} // namespace duckdb

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

@@ -14,7 +14,7 @@ WindowExpression::WindowExpression(ExpressionType type) : ParsedExpression(type,
 
 WindowExpression::WindowExpression(ExpressionType type, string catalog_name, string schema, const string &function_name)
     : ParsedExpression(type, ExpressionClass::WINDOW), catalog(std::move(catalog_name)), schema(std::move(schema)),
-      function_name(StringUtil::Lower(function_name)), ignore_nulls(false) {
+      function_name(StringUtil::Lower(function_name)), ignore_nulls(false), distinct(false) {
 	switch (type) {
 	case ExpressionType::WINDOW_AGGREGATE:
 	case ExpressionType::WINDOW_ROW_NUMBER:
@@ -70,12 +70,18 @@ bool WindowExpression::Equal(const WindowExpression &a, const WindowExpression &
 	if (a.ignore_nulls != b.ignore_nulls) {
 		return false;
 	}
+	if (a.distinct != b.distinct) {
+		return false;
+	}
 	if (!ParsedExpression::ListEquals(a.children, b.children)) {
 		return false;
 	}
 	if (a.start != b.start || a.end != b.end) {
 		return false;
 	}
+	if (a.exclude_clause != b.exclude_clause) {
+		return false;
+	}
 	// check if the framing expressions are equivalentbind_
 	if (!ParsedExpression::Equals(a.start_expr, b.start_expr) || !ParsedExpression::Equals(a.end_expr, b.end_expr) ||
 	    !ParsedExpression::Equals(a.offset_expr, b.offset_expr) ||
@@ -127,11 +133,13 @@ unique_ptr<ParsedExpression> WindowExpression::Copy() const {
 
 	new_window->start = start;
 	new_window->end = end;
+	new_window->exclude_clause = exclude_clause;
 	new_window->start_expr = start_expr ? start_expr->Copy() : nullptr;
 	new_window->end_expr = end_expr ? end_expr->Copy() : nullptr;
 	new_window->offset_expr = offset_expr ? offset_expr->Copy() : nullptr;
 	new_window->default_expr = default_expr ? default_expr->Copy() : nullptr;
 	new_window->ignore_nulls = ignore_nulls;
+	new_window->distinct = distinct;
 
 	return std::move(new_window);
 }

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

@@ -25,6 +25,28 @@ unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
 	                                                      owner_name, if_not_found);
 }
 
+//===--------------------------------------------------------------------===//
+// SetCommentInfo
+//===--------------------------------------------------------------------===//
+SetCommentInfo::SetCommentInfo(CatalogType entry_catalog_type, string entry_catalog_p, string entry_schema_p,
+                               string entry_name_p, Value new_comment_value_p, OnEntryNotFound if_not_found)
+    : AlterInfo(AlterType::SET_COMMENT, std::move(entry_catalog_p), std::move(entry_schema_p), std::move(entry_name_p),
+                if_not_found),
+      entry_catalog_type(entry_catalog_type), comment_value(std::move(new_comment_value_p)) {
+}
+
+CatalogType SetCommentInfo::GetCatalogType() const {
+	return entry_catalog_type;
+}
+
+unique_ptr<AlterInfo> SetCommentInfo::Copy() const {
+	return make_uniq_base<AlterInfo, SetCommentInfo>(entry_catalog_type, catalog, schema, name, comment_value,
+	                                                 if_not_found);
+}
+
+SetCommentInfo::SetCommentInfo() : AlterInfo(AlterType::SET_COMMENT) {
+}
+
 //===--------------------------------------------------------------------===//
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
@@ -132,6 +154,24 @@ unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
 	                                                       expression->Copy());
 }
 
+//===--------------------------------------------------------------------===//
+// SetColumnCommentInfo
+//===--------------------------------------------------------------------===//
+SetColumnCommentInfo::SetColumnCommentInfo() : AlterTableInfo(AlterTableType::SET_COLUMN_COMMENT) {
+}
+
+SetColumnCommentInfo::SetColumnCommentInfo(AlterEntryData data, string column_name, Value comment_value)
+    : AlterTableInfo(AlterTableType::SET_COLUMN_COMMENT, std::move(data)), column_name(std::move(column_name)),
+      comment(std::move(comment_value)) {
+}
+
+SetColumnCommentInfo::~SetColumnCommentInfo() {
+}
+
+unique_ptr<AlterInfo> SetColumnCommentInfo::Copy() const {
+	return make_uniq_base<AlterInfo, SetColumnCommentInfo>(GetAlterEntryData(), column_name, comment);
+}
+
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//

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

@@ -7,6 +7,7 @@ unique_ptr<AttachInfo> AttachInfo::Copy() const {
 	result->name = name;
 	result->path = path;
 	result->options = options;
+	result->on_conflict = on_conflict;
 	return result;
 }
 

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

@@ -0,0 +1,19 @@
+#include "duckdb/parser/parsed_data/comment_on_info.hpp"
+
+namespace duckdb {
+
+CommentOnInfo::CommentOnInfo()
+    : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), name(""), comment(Value()) {
+}
+
+unique_ptr<CommentOnInfo> CommentOnInfo::Copy() const {
+	auto result = make_uniq<CommentOnInfo>();
+	result->type = type;
+	result->catalog = catalog;
+	result->schema = schema;
+	result->name = name;
+	result->comment = comment;
+	return result;
+}
+
+} // namespace duckdb

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

@@ -2,14 +2,20 @@
 
 namespace duckdb {
 
+CreateIndexInfo::CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
+}
+
+CreateIndexInfo::CreateIndexInfo(const duckdb::CreateIndexInfo &info)
+    : CreateInfo(CatalogType::INDEX_ENTRY), table(info.table), index_name(info.index_name), options(info.options),
+      index_type(info.index_type), constraint_type(info.constraint_type), column_ids(info.column_ids),
+      scan_types(info.scan_types), names(info.names) {
+}
+
 unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
-	auto result = make_uniq<CreateIndexInfo>();
+
+	auto result = make_uniq<CreateIndexInfo>(*this);
 	CopyProperties(*result);
 
-	result->index_type = index_type;
-	result->index_name = index_name;
-	result->constraint_type = constraint_type;
-	result->table = table;
 	for (auto &expr : expressions) {
 		result->expressions.push_back(expr->Copy());
 	}
@@ -17,10 +23,6 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 		result->parsed_expressions.push_back(expr->Copy());
 	}
 
-	result->scan_types = scan_types;
-	result->names = names;
-	result->column_ids = column_ids;
-	result->options = options;
 	return std::move(result);
 }
 

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

@@ -19,6 +19,7 @@ void CreateInfo::CopyProperties(CreateInfo &other) const {
 	other.temporary = temporary;
 	other.internal = internal;
 	other.sql = sql;
+	other.comment = comment;
 }
 
 unique_ptr<AlterInfo> CreateInfo::GetAlterInfo() const {