duckdb 0.7.1-dev7.0 → 0.7.1-dev90.0

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/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

@@ -247,6 +247,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/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/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/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/statement/bind_create.cpp

@@ -12,13 +12,11 @@
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/parser/parsed_data/create_database_info.hpp"
-#include "duckdb/function/create_database_extension.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/expression_binder/index_binder.hpp"
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/operator/logical_create.hpp"
@@ -26,13 +24,13 @@
 #include "duckdb/planner/operator/logical_create_table.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
-#include "duckdb/planner/parsed_data/bound_create_function_info.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
 #include "duckdb/parser/constraints/foreign_key_constraint.hpp"
 #include "duckdb/function/scalar_macro_function.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/storage/storage_extension.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/parser/constraints/unique_constraint.hpp"
 #include "duckdb/parser/constraints/list.hpp"
@@ -651,23 +649,27 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	case CatalogType::DATABASE_ENTRY: {
 		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
 		auto &base = (CreateDatabaseInfo &)*stmt.info;
-		string extension_name = base.extension_name;
 		string database_name = base.name;
 		string source_path = base.path;
 
 		auto &config = DBConfig::GetConfig(context);
-		for (auto &extension : config.create_database_extensions) {
-			auto create_database_function_ref =
-			    extension.function(context, extension_name, database_name, source_path, extension.data.get());
-			if (create_database_function_ref) {
-				auto bound_create_database_func = Bind(*create_database_function_ref);
-				result.plan = CreatePlan(*bound_create_database_func);
-				break;
-			}
-		}
-		if (!result.plan) {
+
+		if (config.storage_extensions.empty()) {
 			throw NotImplementedException("CREATE DATABASE not supported in DuckDB yet");
 		}
+		// for now assume only one storage extension provides the custom create_database impl
+		for (auto &extension_entry : config.storage_extensions) {
+			if (extension_entry.second->create_database != nullptr) {
+				auto &storage_extension = extension_entry.second;
+				auto create_database_function_ref = storage_extension->create_database(
+				    storage_extension->storage_info.get(), context, database_name, source_path);
+				if (create_database_function_ref) {
+					auto bound_create_database_func = Bind(*create_database_function_ref);
+					result.plan = CreatePlan(*bound_create_database_func);
+					break;
+				}
+			}
+		}
 		break;
 	}
 	default:

package/src/duckdb/src/planner/binder/statement/bind_detach.cpp

@@ -0,0 +1,19 @@
+#include "duckdb/parser/statement/detach_statement.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/main/config.hpp"
+
+namespace duckdb {
+
+BoundStatement Binder::Bind(DetachStatement &stmt) {
+	BoundStatement result;
+
+	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_DETACH, std::move(stmt.info));
+	result.names = {"Success"};
+	result.types = {LogicalType::BOOLEAN};
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::NOTHING;
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/binder/statement/bind_drop.cpp

@@ -1,9 +1,13 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/bound_tableref.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/standard_entry.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/storage/storage_extension.hpp"
 
 namespace duckdb {
 
@@ -43,10 +47,31 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		stmt.info->schema = entry->schema->name;
 		break;
 	}
-	case CatalogType::DATABASE_ENTRY:
-		// attaching and detaching is read-only
-		stmt.info->catalog = SYSTEM_CATALOG;
-		break;
+	case CatalogType::DATABASE_ENTRY: {
+		auto &base = (DropInfo &)*stmt.info;
+		string database_name = base.name;
+
+		auto &config = DBConfig::GetConfig(context);
+		// for now assume only one storage extension provides the custom drop_database impl
+		for (auto &extension_entry : config.storage_extensions) {
+			if (extension_entry.second->drop_database != nullptr) {
+				continue;
+			}
+			auto &storage_extension = extension_entry.second;
+			auto drop_database_function_ref =
+			    storage_extension->drop_database(storage_extension->storage_info.get(), context, database_name);
+			if (drop_database_function_ref) {
+				auto bound_drop_database_func = Bind(*drop_database_function_ref);
+				result.plan = CreatePlan(*bound_drop_database_func);
+				result.names = {"Success"};
+				result.types = {LogicalType::BOOLEAN};
+				properties.allow_stream_result = false;
+				properties.return_type = StatementReturnType::NOTHING;
+				return result;
+			}
+		}
+		throw BinderException("Drop is not supported for this database!");
+	}
 	default:
 		throw BinderException("Unknown catalog type for drop statement!");
 	}

package/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp

@@ -128,6 +128,8 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	{
 		LateralBinder binder(left_binder, context);
 		result->right = right_binder.Bind(*ref.right);
+		result->correlated_columns = binder.ExtractCorrelatedColumns(right_binder);
+
 		result->lateral = binder.HasCorrelatedColumns();
 		if (result->lateral) {
 			// lateral join: can only be an INNER or LEFT join
@@ -135,7 +137,6 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 				throw BinderException("The combining JOIN type must be INNER or LEFT for a LATERAL reference");
 			}
 		}
-		result->correlated_columns = binder.ExtractCorrelatedColumns(right_binder);
 	}
 
 	vector<unique_ptr<ParsedExpression>> extra_conditions;

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

@@ -90,6 +90,8 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 		return Bind((LogicalPlanStatement &)statement);
 	case StatementType::ATTACH_STATEMENT:
 		return Bind((AttachStatement &)statement);
+	case StatementType::DETACH_STATEMENT:
+		return Bind((DetachStatement &)statement);
 	default: // LCOV_EXCL_START
 		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
 		                              StatementTypeToString(statement.type));

package/src/duckdb/src/planner/expression_binder/lateral_binder.cpp

@@ -39,14 +39,30 @@ BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr,
 }
 
 vector<CorrelatedColumnInfo> LateralBinder::ExtractCorrelatedColumns(Binder &binder) {
+
+	if (correlated_columns.empty()) {
+		return binder.correlated_columns;
+	}
+
+	// clear outer
+	correlated_columns.clear();
 	auto all_correlated_columns = binder.correlated_columns;
-	for (auto &correlated : correlated_columns) {
-		auto entry = std::find(binder.correlated_columns.begin(), binder.correlated_columns.end(), correlated);
-		if (entry == binder.correlated_columns.end()) {
-			throw InternalException("Lateral Binder: could not find correlated column in binder");
+
+	// remove outer from inner
+	for (auto &corr_column : correlated_columns) {
+		auto entry = std::find(binder.correlated_columns.begin(), binder.correlated_columns.end(), corr_column);
+		if (entry != binder.correlated_columns.end()) {
+			binder.correlated_columns.erase(entry);
 		}
-		binder.correlated_columns.erase(entry);
 	}
+
+	// add inner to outer
+	for (auto &corr_column : binder.correlated_columns) {
+		correlated_columns.push_back(corr_column);
+	}
+
+	// clear inner
+	binder.correlated_columns.clear();
 	return all_correlated_columns;
 }
 

package/src/duckdb/src/planner/logical_operator.cpp

@@ -338,6 +338,8 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_DROP:
 		result = LogicalSimple::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_DETACH:
+		throw SerializationException("Logical Detach does not support serialization");
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		result = LogicalExtensionOperator::Deserialize(state, reader);
 		break;

package/src/duckdb/src/planner/planner.cpp

@@ -133,6 +133,7 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 	case StatementType::EXECUTE_STATEMENT:
 	case StatementType::LOGICAL_PLAN_STATEMENT:
 	case StatementType::ATTACH_STATEMENT:
+	case StatementType::DETACH_STATEMENT:
 		CreatePlan(*statement);
 		break;
 	default:

package/src/duckdb/src/storage/storage_info.cpp

@@ -9,7 +9,8 @@ struct StorageVersionInfo {
 	idx_t storage_version;
 };
 
-static StorageVersionInfo storage_version_info[] = {{"v0.6.0 or v0.6.1", 39},
+static StorageVersionInfo storage_version_info[] = {{"v0.7.0", 43},
+                                                    {"v0.6.0 or v0.6.1", 39},
                                                     {"v0.5.0 or v0.5.1", 38},
                                                     {"v0.3.3, v0.3.4 or v0.4.0", 33},
                                                     {"v0.3.2", 31},

package/src/duckdb/src/storage/table/column_data.cpp

@@ -27,8 +27,10 @@ ColumnData::ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t c
 
 ColumnData::ColumnData(ColumnData &other, idx_t start, ColumnData *parent)
     : block_manager(other.block_manager), info(other.info), column_index(other.column_index), start(start),
-      type(std::move(other.type)), parent(parent), updates(std::move(other.updates)),
-      version(parent ? parent->version + 1 : 0) {
+      type(std::move(other.type)), parent(parent), version(parent ? parent->version + 1 : 0) {
+	if (other.updates) {
+		updates = make_unique<UpdateSegment>(*other.updates, *this);
+	}
 	idx_t offset = 0;
 	for (auto segment = other.data.GetRootSegment(); segment; segment = segment->Next()) {
 		auto &other = (ColumnSegment &)*segment;

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -36,6 +36,21 @@ UpdateSegment::UpdateSegment(ColumnData &column_data)
 	this->statistics_update_function = GetStatisticsUpdateFunction(physical_type);
 }
 
+UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
+    : column_data(owner), root(std::move(other.root)), stats(std::move(other.stats)), type_size(other.type_size) {
+
+	this->heap.Move(other.heap);
+
+	initialize_update_function = other.initialize_update_function;
+	merge_update_function = other.merge_update_function;
+	fetch_update_function = other.fetch_update_function;
+	fetch_committed_function = other.fetch_committed_function;
+	fetch_committed_range = other.fetch_committed_range;
+	fetch_row_function = other.fetch_row_function;
+	rollback_update_function = other.rollback_update_function;
+	statistics_update_function = other.statistics_update_function;
+}
+
 UpdateSegment::~UpdateSegment() {
 }
 

package/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp

@@ -422,6 +422,7 @@ typedef enum PGNodeTag {
 	T_PGExportStmt,
 	T_PGImportStmt,
 	T_PGAttachStmt,
+	T_PGDetachStmt,
 	T_PGCreateDatabaseStmt,
 	T_PGUseStmt,
 

package/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp

@@ -2070,6 +2070,20 @@ typedef struct PGAttachStmt
     PGNode *query;
 } PGAttachStmt;
 
+/* ----------------------
+ *		Dettach Statement
+ * ----------------------
+ */
+
+typedef struct PGDetachStmt
+{
+	PGNodeTag		type;
+	char *db_name;         /* list of names of attached databases */
+	bool missing_ok;
+} PGDetachStmt;
+
+
+
 /* ----------------------
  *		CREATE DATABASE Statement
  * ----------------------