duckdb 0.3.2-dev772.0 → 0.3.2-dev788.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev772.0",
+  "version": "0.3.2-dev788.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -27591,8 +27591,6 @@ public:
 private:
 	unique_ptr<TreeNode> CreateTree(PhysicalOperator *root, idx_t depth = 0);
 	void Render(const TreeNode &node, std::ostream &str) const;
-	//! The lock used for flushing information from a thread into the global query profiler
-	mutex flush_lock;
 
 public:
 	DUCKDB_API bool IsEnabled() const;
@@ -27633,6 +27631,8 @@ private:
 
 	//! Whether or not the query profiler is running
 	bool running;
+	//! The lock used for flushing information from a thread into the global query profiler
+	mutex flush_lock;
 
 	//! Whether or not the query requires profiling
 	bool query_requires_profiling;
@@ -27645,7 +27645,7 @@ private:
 	Profiler main_query;
 	//! A map of a Physical Operator pointer to a tree node
 	TreeMap tree_map;
-
+	//! Whether or not we are running as part of a explain_analyze query
 	bool is_explain_analyze;
 
 public:
@@ -27675,12 +27675,12 @@ private:
 class QueryProfilerHistory {
 private:
 	//! Previous Query profilers
-	deque<pair<transaction_t, unique_ptr<QueryProfiler>>> prev_profilers;
+	deque<pair<transaction_t, shared_ptr<QueryProfiler>>> prev_profilers;
 	//! Previous Query profilers size
 	uint64_t prev_profilers_size = 20;
 
 public:
-	deque<pair<transaction_t, unique_ptr<QueryProfiler>>> &GetPrevProfilers() {
+	deque<pair<transaction_t, shared_ptr<QueryProfiler>>> &GetPrevProfilers() {
 		return prev_profilers;
 	}
 	QueryProfilerHistory() {
@@ -38204,6 +38204,9 @@ LogicalType LogicalType::STRUCT(child_list_t<LogicalType> children) {
 	return LogicalType(LogicalTypeId::STRUCT, move(info));
 }
 
+//===--------------------------------------------------------------------===//
+// Map Type
+//===--------------------------------------------------------------------===//
 LogicalType LogicalType::MAP(child_list_t<LogicalType> children) {
 	auto info = make_shared<StructTypeInfo>(move(children));
 	return LogicalType(LogicalTypeId::MAP, move(info));
@@ -38216,6 +38219,16 @@ LogicalType LogicalType::MAP(LogicalType key, LogicalType value) {
 	return LogicalType::MAP(move(child_types));
 }
 
+const LogicalType &MapType::KeyType(const LogicalType &type) {
+	D_ASSERT(type.id() == LogicalTypeId::MAP);
+	return StructType::GetChildTypes(type)[0].second;
+}
+
+const LogicalType &MapType::ValueType(const LogicalType &type) {
+	D_ASSERT(type.id() == LogicalTypeId::MAP);
+	return StructType::GetChildTypes(type)[1].second;
+}
+
 //===--------------------------------------------------------------------===//
 // User Type
 //===--------------------------------------------------------------------===//
@@ -74467,7 +74480,8 @@ string MacroFunction::ValidateArguments(MacroCatalogEntry &macro_func, FunctionE
 			} else if (defaults.find(arg->alias) != defaults.end()) {
 				return StringUtil::Format("Duplicate default parameters %s!", arg->alias);
 			}
-			defaults[arg->alias] = move(arg);
+			auto alias = arg->alias;
+			defaults[alias] = move(arg);
 		} else if (!defaults.empty()) {
 			return "Positional parameters cannot come after parameters with a default value!";
 		} else {
@@ -97527,7 +97541,7 @@ struct ActiveQueryContext {
 };
 
 ClientContext::ClientContext(shared_ptr<DatabaseInstance> database)
-    : profiler(make_unique<QueryProfiler>(*this)), query_profiler_history(make_unique<QueryProfilerHistory>()),
+    : profiler(make_shared<QueryProfiler>(*this)), query_profiler_history(make_unique<QueryProfilerHistory>()),
       db(move(database)), transaction(db->GetTransactionManager(), *this), interrupted(false),
       temporary_objects(make_unique<SchemaCatalogEntry>(&db->GetCatalog(), TEMP_SCHEMA, true)),
       catalog_search_path(make_unique<CatalogSearchPath>(*this)),
@@ -97622,7 +97636,7 @@ string ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bo
 			auto &prev_profilers = query_profiler_history->GetPrevProfilers();
 			prev_profilers.emplace_back(transaction.ActiveTransaction().active_query, move(profiler));
 			// Reinitialize the query profiler
-			profiler = make_unique<QueryProfiler>(*this);
+			profiler = make_shared<QueryProfiler>(*this);
 			// Propagate settings of the saved query into the new profiler.
 			profiler->Propagate(*prev_profilers.back().second);
 			if (prev_profilers.size() >= query_profiler_history->GetPrevProfilersSize()) {
@@ -99884,6 +99898,7 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 
 
 
+#ifndef DISABLE_DUCKDB_REMOTE_INSTALL
 
 
 // LICENSE_CHANGE_BEGIN
@@ -107326,6 +107341,7 @@ inline SSL_CTX *Client::ssl_context() const {
 
 // LICENSE_CHANGE_END
 
+#endif
 
 
 #include <fstream>
@@ -107383,6 +107399,9 @@ void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &exten
 		throw IOException("Failed to read extension from \"%s\": no such file", extension);
 	}
 
+#ifdef DISABLE_DUCKDB_REMOTE_INSTALL
+	throw BinderException("Remote extension installation is disabled through configuration");
+#else
 	string url_template = "http://extensions.duckdb.org/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
 
 	if (is_http_url) {
@@ -107421,6 +107440,7 @@ void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &exten
 	if (out.bad()) {
 		throw IOException("Failed to write extension to %s", local_extension_path);
 	}
+#endif
 }
 
 } // namespace duckdb
@@ -107898,6 +107918,7 @@ void QueryProfiler::StartExplainAnalyze() {
 }
 
 void QueryProfiler::EndQuery() {
+	lock_guard<mutex> guard(flush_lock);
 	if (!IsEnabled() || !running) {
 		return;
 	}
@@ -108056,10 +108077,10 @@ void OperatorProfiler::Flush(const PhysicalOperator *phys_op, ExpressionExecutor
 }
 
 void QueryProfiler::Flush(OperatorProfiler &profiler) {
+	lock_guard<mutex> guard(flush_lock);
 	if (!IsEnabled() || !running) {
 		return;
 	}
-	lock_guard<mutex> guard(flush_lock);
 	for (auto &node : profiler.timings) {
 		auto entry = tree_map.find(node.first);
 		D_ASSERT(entry != tree_map.end());
@@ -120734,8 +120755,8 @@ void Executor::Initialize(PhysicalOperator *plan) {
 		lock_guard<mutex> elock(executor_lock);
 		physical_plan = plan;
 
-		auto &profiler = QueryProfiler::Get(context);
-		profiler.Initialize(physical_plan);
+		this->profiler = context.profiler;
+		profiler->Initialize(physical_plan);
 		this->producer = scheduler.CreateProducer();
 
 		auto root_pipeline = make_shared<Pipeline>(*this);
@@ -121146,9 +121167,7 @@ void Executor::ThrowExceptionInternal() { // LCOV_EXCL_START
 } // LCOV_EXCL_STOP
 
 void Executor::Flush(ThreadContext &tcontext) {
-	lock_guard<mutex> elock(executor_lock);
-	auto &profiler = QueryProfiler::Get(context);
-	profiler.Flush(tcontext.profiler);
+	profiler->Flush(tcontext.profiler);
 }
 
 bool Executor::GetPipelinesProgress(double &current_progress) { // LCOV_EXCL_START
@@ -138759,7 +138778,8 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 				if (macro_func->default_parameters.find(param->alias) != macro_func->default_parameters.end()) {
 					throw ParserException("Duplicate default parameter: '%s'", param->alias);
 				}
-				macro_func->default_parameters[param->alias] = move(param);
+				auto alias = param->alias;
+				macro_func->default_parameters[alias] = move(param);
 			} else if (param->GetExpressionClass() == ExpressionClass::COLUMN_REF) {
 				// positional parameters
 				if (!macro_func->default_parameters.empty()) {

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "c9573d243"
-#define DUCKDB_VERSION "0.3.2-dev772"
+#define DUCKDB_SOURCE_ID "6322c0deb"
+#define DUCKDB_VERSION "0.3.2-dev788"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1097,6 +1097,11 @@ struct StructType {
 	DUCKDB_API static idx_t GetChildCount(const LogicalType &type);
 };
 
+struct MapType {
+	DUCKDB_API static const LogicalType &KeyType(const LogicalType &type);
+	DUCKDB_API static const LogicalType &ValueType(const LogicalType &type);
+};
+
 
 string LogicalTypeIdToString(LogicalTypeId type);
 
@@ -9869,6 +9874,7 @@ class DataChunk;
 class PhysicalOperator;
 class PipelineExecutor;
 class OperatorState;
+class QueryProfiler;
 class ThreadContext;
 class Task;
 
@@ -9968,6 +9974,8 @@ private:
 	vector<pair<ExceptionType, string>> exceptions;
 	//! List of events
 	vector<shared_ptr<Event>> events;
+	//! The query profiler
+	shared_ptr<QueryProfiler> profiler;
 
 	//! The amount of completed pipelines of the query
 	atomic<idx_t> completed_pipelines;
@@ -17117,7 +17125,7 @@ public:
 	DUCKDB_API ~ClientContext();
 
 	//! Query profiler
-	unique_ptr<QueryProfiler> profiler;
+	shared_ptr<QueryProfiler> profiler;
 	//! QueryProfiler History
 	unique_ptr<QueryProfilerHistory> query_profiler_history;
 	//! The database that this client is connected to