duckdb 0.7.1-dev2.0 → 0.7.1-dev284.0

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

@@ -28,7 +28,7 @@ protected:
 	CopyStatement(const CopyStatement &other);
 
 public:
-	unique_ptr<SQLStatement> Copy() const override;
+	DUCKDB_API unique_ptr<SQLStatement> Copy() const override;
 
 private:
 };

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

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/statement/detach_statement.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_data/detach_info.hpp"
+#include "duckdb/parser/sql_statement.hpp"
+
+namespace duckdb {
+
+class DetachStatement : public SQLStatement {
+public:
+	DetachStatement();
+
+	unique_ptr<DetachInfo> info;
+
+protected:
+	DetachStatement(const DetachStatement &other);
+
+public:
+	unique_ptr<SQLStatement> Copy() const override;
+};
+
+} // namespace duckdb

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

@@ -4,6 +4,7 @@
 #include "duckdb/parser/statement/copy_statement.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/parser/statement/delete_statement.hpp"
+#include "duckdb/parser/statement/detach_statement.hpp"
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/parser/statement/execute_statement.hpp"
 #include "duckdb/parser/statement/explain_statement.hpp"

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

@@ -21,7 +21,7 @@ class QueryNode;
 //! SelectStatement is a typical SELECT clause
 class SelectStatement : public SQLStatement {
 public:
-	SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
+	DUCKDB_API SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
 	}
 
 	//! The main query node
@@ -32,9 +32,9 @@ protected:
 
 public:
 	//! Convert the SELECT statement to a string
-	string ToString() const override;
+	DUCKDB_API string ToString() const override;
 	//! Create a copy of this SelectStatement
-	unique_ptr<SQLStatement> Copy() const override;
+	DUCKDB_API unique_ptr<SQLStatement> Copy() const override;
 	//! Serializes a SelectStatement to a stand-alone binary blob
 	void Serialize(Serializer &serializer) const;
 	//! Deserializes a blob back into a SelectStatement, returns nullptr if

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

@@ -15,7 +15,7 @@ namespace duckdb {
 //! Represents a subquery
 class SubqueryRef : public TableRef {
 public:
-	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
+	DUCKDB_API explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
 
 	//! The subquery
 	unique_ptr<SelectStatement> subquery;

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

@@ -20,6 +20,7 @@ class AttachStatement;
 class CallStatement;
 class CopyStatement;
 class CreateStatement;
+class DetachStatement;
 class DeleteStatement;
 class DropStatement;
 class ExtensionStatement;

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

@@ -156,6 +156,7 @@ private:
 	unique_ptr<SQLStatement> TransformShow(duckdb_libpgquery::PGNode *node);
 	unique_ptr<ShowStatement> TransformShowSelect(duckdb_libpgquery::PGNode *node);
 	unique_ptr<AttachStatement> TransformAttach(duckdb_libpgquery::PGNode *node);
+	unique_ptr<DetachStatement> TransformDetach(duckdb_libpgquery::PGNode *node);
 	unique_ptr<SetStatement> TransformUse(duckdb_libpgquery::PGNode *node);
 
 	unique_ptr<PrepareStatement> TransformPrepare(duckdb_libpgquery::PGNode *node);

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

@@ -108,6 +108,9 @@ public:
 
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info);
 	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);
@@ -247,6 +250,7 @@ private:
 	BoundStatement Bind(LoadStatement &stmt);
 	BoundStatement Bind(LogicalPlanStatement &stmt);
 	BoundStatement Bind(AttachStatement &stmt);
+	BoundStatement Bind(DetachStatement &stmt);
 
 	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
 	                             idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,

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

@@ -10,20 +10,27 @@
 
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/common/unordered_map.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 class BoundColumnRefExpression;
 
-//! The INDEX binder is responsible for binding an expression within an Index statement
+//! The IndexBinder is responsible for binding an expression within an index statement
 class IndexBinder : public ExpressionBinder {
 public:
-	IndexBinder(Binder &binder, ClientContext &context);
+	IndexBinder(Binder &binder, ClientContext &context, TableCatalogEntry *table = nullptr,
+	            CreateIndexInfo *info = nullptr);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
-
 	string UnsupportedAggregateMessage() override;
+
+private:
+	// only for WAL replay
+	TableCatalogEntry *table;
+	CreateIndexInfo *info;
 };
 
 } // namespace duckdb

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

@@ -32,11 +32,7 @@ protected:
 		// already resolved
 	}
 	vector<ColumnBinding> GetColumnBindings() override {
-		vector<ColumnBinding> bindings;
-		for (idx_t i = 0; i < types.size(); i++) {
-			bindings.push_back(ColumnBinding(0, i));
-		}
-		return bindings;
+		return GenerateColumnBindings(0, types.size());
 	}
 };
 } // namespace duckdb

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

@@ -33,8 +33,7 @@ protected:
 		         LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
 	}
 	vector<ColumnBinding> GetColumnBindings() override {
-		return {ColumnBinding(0, 0), ColumnBinding(0, 1), ColumnBinding(0, 2),
-		        ColumnBinding(0, 3), ColumnBinding(0, 4), ColumnBinding(0, 5)};
+		return GenerateColumnBindings(0, types.size());
 	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/data_table.hpp

@@ -122,6 +122,12 @@ public:
 	void UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
 	                  const vector<column_t> &column_path, DataChunk &updates);
 
+	//! Add an index to the DataTable. NOTE: for CREATE (UNIQUE) INDEX statements, we use the PhysicalCreateIndex
+	//! operator. This function is only used during the WAL replay, and is a much less performant index creation
+	//! approach.
+	void WALAddIndex(ClientContext &context, unique_ptr<Index> index,
+	                 const vector<unique_ptr<Expression>> &expressions);
+
 	//! Fetches an append lock
 	void AppendLock(TableAppendState &state);
 	//! Begin appending structs to this table, obtaining necessary locks, etc
@@ -176,7 +182,7 @@ public:
 	static bool IsForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, Index &index, ForeignKeyType fk_type);
 
 	//! Initializes a special scan that is used to create an index on the table, it keeps locks on the table
-	void InitializeCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids);
+	void InitializeWALCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids);
 	//! Scans the next chunk for the CREATE INDEX operator
 	bool CreateIndexScan(TableScanState &state, DataChunk &result, TableScanType type);
 

package/src/duckdb/src/include/duckdb/storage/index.hpp

@@ -40,11 +40,11 @@ public:
 	IndexType type;
 	//! Associated table io manager
 	TableIOManager &table_io_manager;
-	//! Column identifiers to extract from the base table
+	//! Column identifiers to extract key columns from the base table
 	vector<column_t> column_ids;
-	//! Unordered_set of column_ids used by the index
+	//! Unordered set of column_ids used by the index
 	unordered_set<column_t> column_id_set;
-	//! Unbound expressions used by the index
+	//! Unbound expressions used by the index during optimizations
 	vector<unique_ptr<Expression>> unbound_expressions;
 	//! The physical types stored in the index
 	vector<PhysicalType> types;
@@ -64,94 +64,103 @@ public:
 	bool track_memory;
 
 public:
-	//! Initialize a scan on the index with the given expression and column ids
-	//! to fetch from the base table when we only have one query predicate
+	//! Initialize a single predicate scan on the index with the given expression and column IDs
 	virtual unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
 	                                                                 ExpressionType expressionType) = 0;
-	//! Initialize a scan on the index with the given expression and column ids
-	//! to fetch from the base table for two query predicates
+	//! Initialize a two predicate scan on the index with the given expression and column IDs
 	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, const Value &low_value,
 	                                                               ExpressionType low_expression_type,
 	                                                               const Value &high_value,
 	                                                               ExpressionType high_expression_type) = 0;
-	//! Perform a lookup on the index, fetching up to max_count result ids. Returns true if all row ids were fetched,
-	//! and false otherwise.
+	//! Performs a lookup on the index, fetching up to max_count result IDs. Returns true if all row IDs were fetched,
+	//! and false otherwise
 	virtual bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
 	                  vector<row_t> &result_ids) = 0;
 
 	//! Obtain a lock on the index
 	virtual void InitializeLock(IndexLock &state);
-	//! Called when data is appended to the index. The lock obtained from InitializeAppend must be held
+	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held
 	virtual bool Append(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
+	//! Obtains a lock and calls Append while holding that lock
 	bool Append(DataChunk &entries, Vector &row_identifiers);
-	//! Verify that data can be appended to the index
+	//! Verify that data can be appended to the index without a constraint violation
 	virtual void VerifyAppend(DataChunk &chunk) = 0;
-	//! Verify that data can be appended to the index
+	//! Verify that data can be appended to the index without a constraint violation using the conflict manager
 	virtual void VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) = 0;
-	//! Verify that data can be appended to the index for foreign key constraint
-	virtual void VerifyAppendForeignKey(DataChunk &chunk) = 0;
-	//! Verify that data can be delete from the index for foreign key constraint
-	virtual void VerifyDeleteForeignKey(DataChunk &chunk) = 0;
+	//! Performs constraint checking for a chunk of input data
+	virtual void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) = 0;
 
-	//! Called when data inside the index is Deleted
+	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
 	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
+	//! Obtains a lock and calls Delete while holding that lock
 	void Delete(DataChunk &entries, Vector &row_identifiers);
 
-	//! Insert data into the index. Does not lock the index.
+	//! Insert a chunk of entries into the index
 	virtual bool Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
 
-	//! Merge other_index into this index.
+	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
+	//! index must also be locked during the merge
 	virtual bool MergeIndexes(IndexLock &state, Index *other_index) = 0;
+	//! Obtains a lock and calls MergeIndexes while holding that lock
 	bool MergeIndexes(Index *other_index);
 
 	//! Returns the string representation of an index
 	virtual string ToString() = 0;
-	//! Verifies that the memory_size value of the index matches its actual size
+	//! Verifies that the in-memory size value of the index matches its actual size
 	virtual void Verify() = 0;
-
-	//! Returns true if the index is affected by updates on the specified column ids, and false otherwise
+	//! Increases the memory size by the difference between the old size and the current size
+	//! and performs verifications
+	virtual void IncreaseAndVerifyMemorySize(idx_t old_memory_size) = 0;
+
+	//! Increases the in-memory size value
+	inline void IncreaseMemorySize(idx_t size) {
+		memory_size += size;
+	};
+	//! Decreases the in-memory size value
+	inline void DecreaseMemorySize(idx_t size) {
+		D_ASSERT(memory_size >= size);
+		memory_size -= size;
+	};
+
+	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
 	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;
 
-	//! Returns how many of the input values were found in the 'input' chunk, with the option to also record what those
-	//! matches were. For this purpose, nulls count as a match, and are returned in 'null_count'
-	virtual void LookupValues(DataChunk &input, ConflictManager &conflict_manager) = 0;
-
 	//! Returns unique flag
 	bool IsUnique() {
 		return (constraint_type == IndexConstraintType::UNIQUE || constraint_type == IndexConstraintType::PRIMARY);
 	}
-	//! Returns primary flag
+	//! Returns primary key flag
 	bool IsPrimary() {
 		return (constraint_type == IndexConstraintType::PRIMARY);
 	}
-	//! Returns foreign flag
+	//! Returns foreign key flag
 	bool IsForeign() {
 		return (constraint_type == IndexConstraintType::FOREIGN);
 	}
-	//! Serializes the index and returns the pair of block_id offset positions
-	virtual BlockPointer Serialize(duckdb::MetaBlockWriter &writer);
-	BlockPointer GetBlockPointer();
 
-	//! Returns block/offset of where index was most recently serialized.
+	//! Serializes the index and returns the pair of block_id offset positions
+	virtual BlockPointer Serialize(MetaBlockWriter &writer);
+	//! Returns the serialized data pointer to the block and offset of the serialized index
 	BlockPointer GetSerializedDataPointer() const {
 		return serialized_data_pointer;
 	}
 
-protected:
+	//! Execute the index expressions on an input chunk
 	void ExecuteExpressions(DataChunk &input, DataChunk &result);
 
-	//! Lock used for updating the index
+protected:
+	//! Lock used for any changes to the index
 	mutex lock;
-
-	//! Pointer to most recently checkpointed index data.
+	//! Pointer to serialized index data
 	BlockPointer serialized_data_pointer;
 
 private:
-	//! Bound expressions used by the index
+	//! Bound expressions used during expression execution
 	vector<unique_ptr<Expression>> bound_expressions;
-	//! Expression executor for the index expressions
+	//! Expression executor to execute the index expressions
 	ExpressionExecutor executor;
 
+	//! Bind the unbound expressions of the index
 	unique_ptr<Expression> BindExpression(unique_ptr<Expression> expr);
 };
 

package/src/duckdb/src/include/duckdb/storage/storage_extension.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/enums/access_mode.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -27,11 +28,17 @@ typedef unique_ptr<Catalog> (*attach_function_t)(StorageExtensionInfo *storage_i
                                                  const string &name, AttachInfo &info, AccessMode access_mode);
 typedef unique_ptr<TransactionManager> (*create_transaction_manager_t)(StorageExtensionInfo *storage_info,
                                                                        AttachedDatabase &db, Catalog &catalog);
+typedef unique_ptr<TableFunctionRef> (*create_database_t)(StorageExtensionInfo *info, ClientContext &context,
+                                                          const string &database_name, const string &source_path);
+typedef unique_ptr<TableFunctionRef> (*drop_database_t)(StorageExtensionInfo *storage_info, ClientContext &context,
+                                                        const string &database_name);
 
 class StorageExtension {
 public:
 	attach_function_t attach;
 	create_transaction_manager_t create_transaction_manager;
+	create_database_t create_database;
+	drop_database_t drop_database;
 
 	//! Additional info passed to the various storage functions
 	shared_ptr<StorageExtensionInfo> storage_info;

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

@@ -23,6 +23,8 @@ struct UpdateNode;
 class UpdateSegment {
 public:
 	UpdateSegment(ColumnData &column_data);
+	// Construct a duplicate of 'other' with 'new_owner' as it's column data
+	UpdateSegment(UpdateSegment &other, ColumnData &new_owner);
 	~UpdateSegment();
 
 	ColumnData &column_data;

package/src/duckdb/src/include/duckdb/storage/write_ahead_log.hpp

@@ -15,6 +15,7 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/storage/storage_info.hpp"
 
@@ -77,6 +78,9 @@ protected:
 	void ReplayCreateTableMacro();
 	void ReplayDropTableMacro();
 
+	void ReplayCreateIndex();
+	void ReplayDropIndex();
+
 	void ReplayUseTable();
 	void ReplayInsert();
 	void ReplayDelete();
@@ -125,6 +129,9 @@ public:
 	void WriteCreateTableMacro(TableMacroCatalogEntry *entry);
 	void WriteDropTableMacro(TableMacroCatalogEntry *entry);
 
+	void WriteCreateIndex(IndexCatalogEntry *entry);
+	void WriteDropIndex(IndexCatalogEntry *entry);
+
 	void WriteCreateType(TypeCatalogEntry *entry);
 	void WriteDropType(TypeCatalogEntry *entry);
 	//! Sets the table used for subsequent insert/delete/update commands

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

@@ -665,6 +665,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 			statement = std::move(copied_statement);
 			break;
 		}
+#ifndef DUCKDB_ALTERNATIVE_VERIFY
 		case StatementType::COPY_STATEMENT:
 		case StatementType::INSERT_STATEMENT:
 		case StatementType::DELETE_STATEMENT:
@@ -685,6 +686,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 			statement = std::move(parser.statements[0]);
 			break;
 		}
+#endif
 		default:
 			statement = std::move(copied_statement);
 			break;

package/src/duckdb/src/main/extension/extension_alias.cpp

@@ -24,8 +24,9 @@ ExtensionAlias ExtensionHelper::GetExtensionAlias(idx_t index) {
 }
 
 string ExtensionHelper::ApplyExtensionAlias(string extension_name) {
+	auto lname = StringUtil::Lower(extension_name);
 	for (idx_t index = 0; internal_aliases[index].alias; index++) {
-		if (extension_name == internal_aliases[index].alias) {
+		if (lname == internal_aliases[index].alias) {
 			return internal_aliases[index].extension;
 		}
 	}

package/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp

@@ -83,12 +83,8 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 						*node_ptr = std::move(cross_product);
 						return;
 					}
-					case JoinType::INNER:
-					case JoinType::LEFT:
-					case JoinType::RIGHT:
-					case JoinType::OUTER: {
-						// inner/left/right/full outer join, replace with cross product
-						// since the condition is always true, left/right/outer join are equivalent to inner join here
+					case JoinType::INNER: {
+						// inner, replace with cross product
 						auto cross_product =
 						    LogicalCrossProduct::Create(std::move(join.children[0]), std::move(join.children[1]));
 						*node_ptr = std::move(cross_product);

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

@@ -16,6 +16,9 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	for (auto &expr : expressions) {
 		result->expressions.push_back(expr->Copy());
 	}
+	for (auto &expr : parsed_expressions) {
+		result->parsed_expressions.push_back(expr->Copy());
+	}
 
 	result->scan_types = scan_types;
 	result->names = names;

package/src/duckdb/src/parser/statement/copy_statement.cpp

@@ -11,16 +11,6 @@ CopyStatement::CopyStatement(const CopyStatement &other) : SQLStatement(other),
 	}
 }
 
-string ConvertOptionValueToString(const Value &val) {
-	auto type = val.type().id();
-	switch (type) {
-	case LogicalTypeId::VARCHAR:
-		return KeywordHelper::WriteOptionallyQuoted(val.ToString());
-	default:
-		return val.ToString();
-	}
-}
-
 string CopyStatement::CopyOptionsToString(const string &format,
                                           const case_insensitive_map_t<vector<Value>> &options) const {
 	if (format.empty() && options.empty()) {
@@ -45,15 +35,14 @@ string CopyStatement::CopyOptionsToString(const string &format,
 			// Options like HEADER don't need an explicit value
 			// just providing the name already sets it to true
 		} else if (values.size() == 1) {
-			result += ConvertOptionValueToString(values[0]);
+			result += values[0].ToSQLString();
 		} else {
 			result += "( ";
 			for (idx_t i = 0; i < values.size(); i++) {
-				auto &value = values[i];
 				if (i) {
 					result += ", ";
 				}
-				result += KeywordHelper::WriteOptionallyQuoted(value.ToString());
+				result += values[i].ToSQLString();
 			}
 			result += " )";
 		}

package/src/duckdb/src/parser/statement/delete_statement.cpp

@@ -13,6 +13,9 @@ DeleteStatement::DeleteStatement(const DeleteStatement &other) : SQLStatement(ot
 	for (const auto &using_clause : other.using_clauses) {
 		using_clauses.push_back(using_clause->Copy());
 	}
+	for (auto &expr : other.returning_list) {
+		returning_list.emplace_back(expr->Copy());
+	}
 	cte_map = other.cte_map.Copy();
 }
 

package/src/duckdb/src/parser/statement/detach_statement.cpp

@@ -0,0 +1,15 @@
+#include "duckdb/parser/statement/detach_statement.hpp"
+
+namespace duckdb {
+
+DetachStatement::DetachStatement() : SQLStatement(StatementType::DETACH_STATEMENT) {
+}
+
+DetachStatement::DetachStatement(const DetachStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
+unique_ptr<SQLStatement> DetachStatement::Copy() const {
+	return unique_ptr<DetachStatement>(new DetachStatement(*this));
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/statement/insert_statement.cpp

@@ -13,6 +13,9 @@ OnConflictInfo::OnConflictInfo(const OnConflictInfo &other)
 	if (other.set_info) {
 		set_info = other.set_info->Copy();
 	}
+	if (other.condition) {
+		condition = other.condition->Copy();
+	}
 }
 
 unique_ptr<OnConflictInfo> OnConflictInfo::Copy() const {
@@ -28,6 +31,12 @@ InsertStatement::InsertStatement(const InsertStatement &other)
       select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(other.select_statement->Copy())),
       columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog) {
 	cte_map = other.cte_map.Copy();
+	for (auto &expr : other.returning_list) {
+		returning_list.emplace_back(expr->Copy());
+	}
+	if (other.table_ref) {
+		table_ref = other.table_ref->Copy();
+	}
 	if (other.on_conflict_info) {
 		on_conflict_info = other.on_conflict_info->Copy();
 	}

package/src/duckdb/src/parser/statement/update_statement.cpp

@@ -27,6 +27,9 @@ UpdateStatement::UpdateStatement(const UpdateStatement &other)
 	if (other.from_table) {
 		from_table = other.from_table->Copy();
 	}
+	for (auto &expr : other.returning_list) {
+		returning_list.emplace_back(expr->Copy());
+	}
 	cte_map = other.cte_map.Copy();
 }
 

package/src/duckdb/src/parser/transform/expression/transform_case.cpp

@@ -9,16 +9,16 @@ unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCas
 	D_ASSERT(root);
 
 	auto case_node = make_unique<CaseExpression>();
+	auto root_arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
 	for (auto cell = root->args->head; cell != nullptr; cell = cell->next) {
 		CaseCheck case_check;
 
 		auto w = reinterpret_cast<duckdb_libpgquery::PGCaseWhen *>(cell->data.ptr_value);
 		auto test_raw = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->expr));
 		unique_ptr<ParsedExpression> test;
-		auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
-		if (arg) {
+		if (root_arg) {
 			case_check.when_expr =
-			    make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(arg), std::move(test_raw));
+			    make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, root_arg->Copy(), std::move(test_raw));
 		} else {
 			case_check.when_expr = std::move(test_raw);
 		}

package/src/duckdb/src/parser/transform/statement/transform_create_database.cpp

@@ -11,7 +11,6 @@ unique_ptr<CreateStatement> Transformer::TransformCreateDatabase(duckdb_libpgque
 	auto result = make_unique<CreateStatement>();
 	auto info = make_unique<CreateDatabaseInfo>();
 
-	info->extension_name = stmt->extension ? stmt->extension : string();
 	info->path = stmt->path ? stmt->path : string();
 
 	auto qualified_name = TransformQualifiedName(stmt->name);

package/src/duckdb/src/parser/transform/statement/transform_detach.cpp

@@ -0,0 +1,19 @@
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/statement/detach_statement.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+unique_ptr<DetachStatement> Transformer::TransformDetach(duckdb_libpgquery::PGNode *node) {
+	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDetachStmt *>(node);
+	auto result = make_unique<DetachStatement>();
+	auto info = make_unique<DetachInfo>();
+	info->name = stmt->db_name;
+	info->if_exists = stmt->missing_ok;
+
+	result->info = std::move(info);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/transformer.cpp

@@ -145,6 +145,8 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return TransformAlterSequence(stmt);
 	case duckdb_libpgquery::T_PGAttachStmt:
 		return TransformAttach(stmt);
+	case duckdb_libpgquery::T_PGDetachStmt:
+		return TransformDetach(stmt);
 	case duckdb_libpgquery::T_PGUseStmt:
 		return TransformUse(stmt);
 	case duckdb_libpgquery::T_PGCreateDatabaseStmt:

package/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp

@@ -72,6 +72,9 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 		for (const auto &element_val : ListValue::GetChildren(value)) {
 			values.push_back(NegatePercentileValue(element_val, desc));
 		}
+		if (values.empty()) {
+			throw BinderException("Empty list in percentile not allowed");
+		}
 		bound.expr = make_unique<BoundConstantExpression>(Value::LIST(values));
 	} else {
 		bound.expr = make_unique<BoundConstantExpression>(NegatePercentileValue(value, desc));