duckdb 0.6.2-dev1170.0 → 0.6.2-dev1178.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev1170.0",
+  "version": "0.6.2-dev1178.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev1170"
+#define DUCKDB_VERSION "0.6.2-dev1178"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "72d187c5ff"
+#define DUCKDB_SOURCE_ID "b0c4f53085"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/function/create_database_extension.hpp

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/create_database_extension.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+class ClientContext;
+class TableFunctionRef;
+
+struct CreateDatabaseExtensionData {
+	virtual ~CreateDatabaseExtensionData() {
+	}
+};
+
+typedef unique_ptr<TableFunctionRef> (*create_database_t)(ClientContext &context, const string &extension_name,
+                                                          const string &database_name, const string &source_path,
+                                                          CreateDatabaseExtensionData *data);
+
+struct CreateDatabaseExtension {
+	explicit CreateDatabaseExtension(create_database_t function,
+	                                 unique_ptr<CreateDatabaseExtensionData> data_p = nullptr)
+	    : function(function), data(move(data_p)) {
+	}
+
+	create_database_t function;
+	unique_ptr<CreateDatabaseExtensionData> data;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/config.hpp

@@ -25,6 +25,7 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/replacement_open.hpp"
 #include "duckdb/function/replacement_scan.hpp"
+#include "duckdb/function/create_database_extension.hpp"
 #include "duckdb/optimizer/optimizer_extension.hpp"
 #include "duckdb/parser/parser_extension.hpp"
 #include "duckdb/planner/operator_extension.hpp"
@@ -183,6 +184,8 @@ public:
 	shared_ptr<Allocator> default_allocator;
 	//! Extensions made to binder
 	vector<std::unique_ptr<OperatorExtension>> operator_extensions;
+	//! Extensions made to binder to implement the create_database functionality
+	vector<CreateDatabaseExtension> create_database_extensions;
 
 public:
 	DUCKDB_API static DBConfig &GetConfig(ClientContext &context);

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_database_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_data/create_info.hpp"
+
+namespace duckdb {
+
+struct CreateDatabaseInfo : public CreateInfo {
+	CreateDatabaseInfo() : CreateInfo(CatalogType::DATABASE_ENTRY) {
+	}
+
+	//! Extension name which creates databases
+	string extension_name;
+
+	//! Name of the database
+	string name;
+
+	//! Source path of the database if it's created from another database
+	string path;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateDatabaseInfo>();
+		CopyProperties(*result);
+		result->extension_name = extension_name;
+		result->name = name;
+		result->path = path;
+		return move(result);
+	}
+
+	static unique_ptr<CreateDatabaseInfo> Deserialize(Deserializer &deserializer) {
+		auto result = make_unique<CreateDatabaseInfo>();
+		result->DeserializeBase(deserializer);
+		return result;
+	}
+
+protected:
+	void SerializeInternal(Serializer &) const override {
+		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
+	}
+};
+
+} // namespace duckdb

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

@@ -119,6 +119,8 @@ private:
 	unique_ptr<CreateStatement> TransformCreateFunction(duckdb_libpgquery::PGNode *node);
 	//! Transform a Postgres duckdb_libpgquery::T_PGCreateTypeStmt node into CreateStatement
 	unique_ptr<CreateStatement> TransformCreateType(duckdb_libpgquery::PGNode *node);
+	//! Transform a Postgres duckdb_libpgquery::T_PGCreateDatabaseStmt node into a CreateStatement
+	unique_ptr<CreateStatement> TransformCreateDatabase(duckdb_libpgquery::PGNode *node);
 	//! Transform a Postgres duckdb_libpgquery::T_PGAlterSeqStmt node into CreateStatement
 	unique_ptr<AlterStatement> TransformAlterSequence(duckdb_libpgquery::PGNode *node);
 	//! Transform a Postgres duckdb_libpgquery::T_PGDropStmt node into a Drop[Table,Schema]Statement

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

@@ -4,6 +4,7 @@
 #include "duckdb/parser/parsed_data/create_schema_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/create_database_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
 
 namespace duckdb {
@@ -38,6 +39,8 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 		return CreateSchemaInfo::Deserialize(deserializer);
 	case CatalogType::VIEW_ENTRY:
 		return CreateViewInfo::Deserialize(deserializer);
+	case CatalogType::DATABASE_ENTRY:
+		return CreateDatabaseInfo::Deserialize(deserializer);
 	default:
 		throw NotImplementedException("Cannot deserialize '%s'", CatalogTypeToString(type));
 	}

package/src/duckdb/src/parser/transform/helpers/nodetype_to_string.cpp

@@ -816,6 +816,8 @@ std::string Transformer::NodetypeToString(duckdb_libpgquery::PGNodeTag type) { /
 		return "T_PGAttachStmt";
 	case duckdb_libpgquery::T_PGUseStmt:
 		return "T_PGUseStmt";
+	case duckdb_libpgquery::T_PGCreateDatabaseStmt:
+		return "T_PGCreateDatabaseStmt";
 	default:
 		return "(UNKNOWN)";
 	}

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

@@ -0,0 +1,29 @@
+#include "duckdb/parser/statement/create_statement.hpp"
+#include "duckdb/parser/parsed_data/create_database_info.hpp"
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
+
+namespace duckdb {
+
+unique_ptr<CreateStatement> Transformer::TransformCreateDatabase(duckdb_libpgquery::PGNode *node) {
+	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateDatabaseStmt *>(node);
+	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);
+	if (!IsInvalidCatalog(qualified_name.catalog)) {
+		throw ParserException("Expected \"CREATE DATABASE database\" ");
+	}
+
+	info->catalog = qualified_name.catalog;
+	info->name = qualified_name.name;
+
+	result->info = move(info);
+	return result;
+}
+
+} // namespace duckdb

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

@@ -147,6 +147,8 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return TransformAttach(stmt);
 	case duckdb_libpgquery::T_PGUseStmt:
 		return TransformUse(stmt);
+	case duckdb_libpgquery::T_PGCreateDatabaseStmt:
+		return TransformCreateDatabase(stmt);
 	default:
 		throw NotImplementedException(NodetypeToString(stmt->type));
 	}

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

@@ -10,6 +10,9 @@
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #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"
@@ -615,6 +618,28 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		}
 		break;
 	}
+	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) {
+			throw NotImplementedException("CREATE DATABASE not supported in DuckDB yet");
+		}
+		break;
+	}
 	default:
 		throw Exception("Unrecognized type!");
 	}

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_PGCreateDatabaseStmt,
 	T_PGUseStmt,
 
 	/*

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

@@ -2069,6 +2069,17 @@ typedef struct PGAttachStmt
     PGNode *query;
 } PGAttachStmt;
 
+/* ----------------------
+ *		CREATE DATABASE Statement
+ * ----------------------
+ */
+typedef struct PGCreateDatabaseStmt
+{
+	PGNodeTag	type;
+	PGRangeVar *name;			/* The name of the created database */
+	char *extension;			/* The name of the extension which will create the database */
+	char *path;					/* The file path of the to-be-created database */
+} PGCreateDatabaseStmt;
 
 /* ----------------------
  *		Use Statement