duckdb 0.3.2-dev735.0 → 0.3.2-dev780.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev735.0",
+  "version": "0.3.2-dev780.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() {
@@ -33840,13 +33840,14 @@ void ValidityMask::Slice(const ValidityMask &other, idx_t offset) {
 		Initialize(other);
 		return;
 	}
-	Initialize(STANDARD_VECTOR_SIZE);
+	ValidityMask new_mask(STANDARD_VECTOR_SIZE);
 
 // FIXME THIS NEEDS FIXING!
 #if 1
 	for (idx_t i = offset; i < STANDARD_VECTOR_SIZE; i++) {
-		Set(i - offset, other.RowIsValid(i));
+		new_mask.Set(i - offset, other.RowIsValid(i));
 	}
+	Initialize(new_mask);
 #else
 	// first shift the "whole" units
 	idx_t entire_units = offset / BITS_PER_VALUE;
@@ -33854,7 +33855,7 @@ void ValidityMask::Slice(const ValidityMask &other, idx_t offset) {
 	if (entire_units > 0) {
 		idx_t validity_idx;
 		for (validity_idx = 0; validity_idx + entire_units < STANDARD_ENTRY_COUNT; validity_idx++) {
-			validity_mask[validity_idx] = other.validity_mask[validity_idx + entire_units];
+			new_mask.validity_mask[validity_idx] = other.validity_mask[validity_idx + entire_units];
 		}
 	}
 	// now we shift the remaining sub units
@@ -33869,15 +33870,17 @@ void ValidityMask::Slice(const ValidityMask &other, idx_t offset) {
 	if (sub_units > 0) {
 		idx_t validity_idx;
 		for (validity_idx = 0; validity_idx + 1 < STANDARD_ENTRY_COUNT; validity_idx++) {
-			validity_mask[validity_idx] = (other.validity_mask[validity_idx] >> sub_units) |
-			                              (other.validity_mask[validity_idx + 1] << (BITS_PER_VALUE - sub_units));
+			new_mask.validity_mask[validity_idx] =
+			    (other.validity_mask[validity_idx] >> sub_units) |
+			    (other.validity_mask[validity_idx + 1] << (BITS_PER_VALUE - sub_units));
 		}
-		validity_mask[validity_idx] >>= sub_units;
+		new_mask.validity_mask[validity_idx] >>= sub_units;
 	}
 #ifdef DEBUG
 	for (idx_t i = offset; i < STANDARD_VECTOR_SIZE; i++) {
-		D_ASSERT(RowIsValid(i - offset) == other.RowIsValid(i));
+		D_ASSERT(new_mask.RowIsValid(i - offset) == other.RowIsValid(i));
 	}
+	Initialize(new_mask);
 #endif
 #endif
 }
@@ -63950,10 +63953,7 @@ namespace duckdb {
 //! LogicalLimit represents a LIMIT clause
 class LogicalLimit : public LogicalOperator {
 public:
-	LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr<Expression> limit, unique_ptr<Expression> offset)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(limit_val), offset_val(offset_val),
-	      limit(move(limit)), offset(move(offset)) {
-	}
+	LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr<Expression> limit, unique_ptr<Expression> offset);
 
 	//! Limit and offset values in case they are constants, used in optimizations.
 	int64_t limit_val;
@@ -63964,14 +63964,12 @@ public:
 	unique_ptr<Expression> offset;
 
 public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
+	vector<ColumnBinding> GetColumnBindings() override;
+
+	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
+	void ResolveTypes() override;
 };
 } // namespace duckdb
 
@@ -64394,23 +64392,18 @@ namespace duckdb {
 //! LogicalSample represents a SAMPLE clause
 class LogicalSample : public LogicalOperator {
 public:
-	LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(move(sample_options_p)) {
-		children.push_back(move(child));
-	}
+	LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child);
 
 	//! The sample options
 	unique_ptr<SampleOptions> sample_options;
 
 public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
+	vector<ColumnBinding> GetColumnBindings() override;
+
+	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
+	void ResolveTypes() override;
 };
 
 } // namespace duckdb
@@ -97534,7 +97527,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)),
@@ -97629,7 +97622,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()) {
@@ -107905,6 +107898,7 @@ void QueryProfiler::StartExplainAnalyze() {
 }
 
 void QueryProfiler::EndQuery() {
+	lock_guard<mutex> guard(flush_lock);
 	if (!IsEnabled() || !running) {
 		return;
 	}
@@ -108063,10 +108057,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());
@@ -120741,8 +120735,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);
@@ -121153,9 +121147,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
@@ -150796,6 +150788,33 @@ void LogicalJoin::GetExpressionBindings(Expression &expr, unordered_set<idx_t> &
 } // namespace duckdb
 
 
+namespace duckdb {
+
+LogicalLimit::LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr<Expression> limit,
+                           unique_ptr<Expression> offset)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(limit_val), offset_val(offset_val),
+      limit(move(limit)), offset(move(offset)) {
+}
+
+vector<ColumnBinding> LogicalLimit::GetColumnBindings() {
+	return children[0]->GetColumnBindings();
+}
+
+idx_t LogicalLimit::EstimateCardinality(ClientContext &context) {
+	auto child_cardinality = children[0]->EstimateCardinality(context);
+	if (limit_val >= 0 && idx_t(limit_val) < child_cardinality) {
+		child_cardinality = limit_val;
+	}
+	return child_cardinality;
+}
+
+void LogicalLimit::ResolveTypes() {
+	types = children[0]->types;
+}
+
+} // namespace duckdb
+
+
 namespace duckdb {
 
 LogicalProjection::LogicalProjection(idx_t table_index, vector<unique_ptr<Expression>> select_list)
@@ -150815,6 +150834,37 @@ void LogicalProjection::ResolveTypes() {
 } // namespace duckdb
 
 
+namespace duckdb {
+
+LogicalSample::LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(move(sample_options_p)) {
+	children.push_back(move(child));
+}
+
+vector<ColumnBinding> LogicalSample::GetColumnBindings() {
+	return children[0]->GetColumnBindings();
+}
+
+idx_t LogicalSample::EstimateCardinality(ClientContext &context) {
+	auto child_cardinality = children[0]->EstimateCardinality(context);
+	if (sample_options->is_percentage) {
+		return idx_t(child_cardinality * sample_options->sample_size.GetValue<double>());
+	} else {
+		auto sample_size = sample_options->sample_size.GetValue<uint64_t>();
+		if (sample_size < child_cardinality) {
+			return sample_size;
+		}
+	}
+	return child_cardinality;
+}
+
+void LogicalSample::ResolveTypes() {
+	types = children[0]->types;
+}
+
+} // namespace duckdb
+
+
 namespace duckdb {
 
 vector<ColumnBinding> LogicalUnnest::GetColumnBindings() {
@@ -153665,6 +153715,7 @@ void __fastpack64(const uint64_t *__restrict in, uint32_t *__restrict out);
 // LICENSE_CHANGE_END
 
 
+
 #include <stdexcept>
 
 namespace duckdb_fastpforlib {

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 "19f1a4d63"
-#define DUCKDB_VERSION "0.3.2-dev735"
+#define DUCKDB_SOURCE_ID "3e55c44bd"
+#define DUCKDB_VERSION "0.3.2-dev780"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -9869,6 +9869,7 @@ class DataChunk;
 class PhysicalOperator;
 class PipelineExecutor;
 class OperatorState;
+class QueryProfiler;
 class ThreadContext;
 class Task;
 
@@ -9968,6 +9969,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 +17120,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