duckdb 0.4.1-dev464.0 → 0.4.1-dev484.0

package/src/duckdb.cpp

@@ -61691,7 +61691,7 @@ void PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk,
 
 namespace duckdb {
 
-//! PhysicalVacuum represents an etension LOAD operation
+//! PhysicalLoad represents an extension LOAD operation
 class PhysicalLoad : public PhysicalOperator {
 public:
 	explicit PhysicalLoad(unique_ptr<LoadInfo> info, idx_t estimated_cardinality)
@@ -62629,27 +62629,236 @@ void PhysicalTransaction::GetData(ExecutionContext &context, DataChunk &chunk, G
 
 
 
+
 namespace duckdb {
 
-//! PhysicalVacuum represents a VACUUM operation (e.g. VACUUM or ANALYZE)
+//! PhysicalVacuum represents a VACUUM operation (i.e. VACUUM or ANALYZE)
 class PhysicalVacuum : public PhysicalOperator {
 public:
-	explicit PhysicalVacuum(unique_ptr<VacuumInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::VACUUM, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
-	}
+	PhysicalVacuum(unique_ptr<VacuumInfo> info, idx_t estimated_cardinality);
 
 	unique_ptr<VacuumInfo> info;
 
+private:
+	unordered_map<idx_t, idx_t> column_id_map;
+
 public:
+	// Source interface
 	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
 	             LocalSourceState &lstate) const override;
+
+public:
+	// Sink interface
+	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
+	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
+
+	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
+	                    DataChunk &input) const override;
+	void Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const override;
+	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+	                          GlobalSinkState &gstate) const override;
+
+	bool IsSink() const override {
+		return info->has_table;
+	}
+
+	bool ParallelSink() const override {
+		return IsSink();
+	}
 };
 
 } // namespace duckdb
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_get.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+//! LogicalGet represents a scan operation from a data source
+class LogicalGet : public LogicalOperator {
+public:
+	LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
+	           vector<LogicalType> returned_types, vector<string> returned_names);
+
+	//! The table index in the current bind context
+	idx_t table_index;
+	//! The function that is called
+	TableFunction function;
+	//! The bind data of the function
+	unique_ptr<FunctionData> bind_data;
+	//! The types of ALL columns that can be returned by the table function
+	vector<LogicalType> returned_types;
+	//! The names of ALL columns that can be returned by the table function
+	vector<string> names;
+	//! Bound column IDs
+	vector<column_t> column_ids;
+	//! Filters pushed down for table scan
+	TableFilterSet table_filters;
+
+	string GetName() const override;
+	string ParamsToString() const override;
+	//! Returns the underlying table that is being scanned, or nullptr if there is none
+	TableCatalogEntry *GetTable() const;
+
+public:
+	vector<ColumnBinding> GetColumnBindings() override;
+
+	idx_t EstimateCardinality(ClientContext &context) override;
+
+protected:
+	void ResolveTypes() override;
+};
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/distinct_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
 namespace duckdb {
+class Serializer;
+class Deserializer;
+class Vector;
+
+class DistinctStatistics : public BaseStatistics {
+public:
+	DistinctStatistics();
+	explicit DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count);
+
+	//! The HLL of the table
+	unique_ptr<HyperLogLog> log;
+	//! How many values have been sampled into the HLL
+	atomic<idx_t> sample_count;
+	//! How many values have been inserted (before sampling)
+	atomic<idx_t> total_count;
+
+public:
+	void Merge(const BaseStatistics &other) override;
+
+	unique_ptr<BaseStatistics> Copy() const override;
+
+	void Serialize(Serializer &serializer) const override;
+	void Serialize(FieldWriter &writer) const override;
+
+	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &source);
+	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
+
+	void Update(Vector &update, idx_t count, bool sample = true);
+	void Update(VectorData &update_data, const LogicalType &ptype, idx_t count, bool sample = true);
+
+	string ToString() const override;
+	idx_t GetCount() const;
+
+private:
+	//! For distinct statistics we sample the input to speed up insertions
+	static constexpr const double SAMPLE_RATE = 0.1;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+PhysicalVacuum::PhysicalVacuum(unique_ptr<VacuumInfo> info_p, idx_t estimated_cardinality)
+    : PhysicalOperator(PhysicalOperatorType::VACUUM, {LogicalType::BOOLEAN}, estimated_cardinality),
+      info(move(info_p)) {
+	if (info->has_table) {
+		auto &get = (LogicalGet &)*info->bound_ref->get;
+		for (idx_t i = 0; i < get.column_ids.size(); i++) {
+			column_id_map[i] = get.column_ids[i];
+		}
+	}
+}
+
+class VacuumLocalSinkState : public LocalSinkState {
+public:
+	explicit VacuumLocalSinkState(VacuumInfo &info) {
+		for (idx_t col_idx = 0; col_idx < info.columns.size(); col_idx++) {
+			column_distinct_stats.push_back(make_unique<DistinctStatistics>());
+		}
+	};
+
+	vector<unique_ptr<DistinctStatistics>> column_distinct_stats;
+};
+
+unique_ptr<LocalSinkState> PhysicalVacuum::GetLocalSinkState(ExecutionContext &context) const {
+	return make_unique<VacuumLocalSinkState>(*info);
+}
+
+class VacuumGlobalSinkState : public GlobalSinkState {
+public:
+	explicit VacuumGlobalSinkState(VacuumInfo &info) {
+		for (idx_t col_idx = 0; col_idx < info.columns.size(); col_idx++) {
+			column_distinct_stats.push_back(make_unique<DistinctStatistics>());
+		}
+	};
+
+	mutex stats_lock;
+	vector<unique_ptr<DistinctStatistics>> column_distinct_stats;
+};
+
+unique_ptr<GlobalSinkState> PhysicalVacuum::GetGlobalSinkState(ClientContext &context) const {
+	return make_unique<VacuumGlobalSinkState>(*info);
+}
+
+SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
+                                    DataChunk &input) const {
+	auto &lstate = (VacuumLocalSinkState &)lstate_p;
+	D_ASSERT(lstate.column_distinct_stats.size() == column_id_map.size());
+
+	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
+		lstate.column_distinct_stats[col_idx]->Update(input.data[col_idx], input.size(), false);
+	}
+
+	return SinkResultType::NEED_MORE_INPUT;
+}
+
+void PhysicalVacuum::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
+	auto &gstate = (VacuumGlobalSinkState &)gstate_p;
+	auto &lstate = (VacuumLocalSinkState &)lstate_p;
+
+	lock_guard<mutex> lock(gstate.stats_lock);
+	D_ASSERT(gstate.column_distinct_stats.size() == lstate.column_distinct_stats.size());
+	for (idx_t col_idx = 0; col_idx < gstate.column_distinct_stats.size(); col_idx++) {
+		gstate.column_distinct_stats[col_idx]->Merge(*lstate.column_distinct_stats[col_idx]);
+	}
+}
+
+SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+                                          GlobalSinkState &gstate) const {
+	auto &sink = (VacuumGlobalSinkState &)gstate;
+
+	auto table = info->bound_ref->table;
+	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {
+		table->storage->SetStatistics(column_id_map.at(col_idx), [&](BaseStatistics &stats) {
+			stats.distinct_stats = move(sink.column_distinct_stats[col_idx]);
+		});
+	}
+
+	return SinkFinalizeType::READY;
+}
 
 void PhysicalVacuum::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                              LocalSourceState &lstate) const {
@@ -76713,57 +76922,6 @@ protected:
 
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalGet represents a scan operation from a data source
-class LogicalGet : public LogicalOperator {
-public:
-	LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
-	           vector<LogicalType> returned_types, vector<string> returned_names);
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The function that is called
-	TableFunction function;
-	//! The bind data of the function
-	unique_ptr<FunctionData> bind_data;
-	//! The types of ALL columns that can be returned by the table function
-	vector<LogicalType> returned_types;
-	//! The names of ALL columns that can be returned by the table function
-	vector<string> names;
-	//! Bound column IDs
-	vector<column_t> column_ids;
-	//! Filters pushed down for table scan
-	TableFilterSet table_filters;
-
-	string GetName() const override;
-	string ParamsToString() const override;
-	//! Returns the underlying table that is being scanned, or nullptr if there is none
-	TableCatalogEntry *GetTable() const;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
 
 
 namespace duckdb {
@@ -77705,6 +77863,14 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalShow &op)
 } // namespace duckdb
 
 
+
+
+
+
+
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -77737,15 +77903,6 @@ protected:
 } // namespace duckdb
 
 
-
-
-
-
-
-
-
-
-
 namespace duckdb {
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSimple &op) {
@@ -77758,9 +77915,19 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSimple &op
 	case LogicalOperatorType::LOGICAL_TRANSACTION:
 		return make_unique<PhysicalTransaction>(unique_ptr_cast<ParseInfo, TransactionInfo>(move(op.info)),
 		                                        op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		return make_unique<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(move(op.info)),
-		                                   op.estimated_cardinality);
+	case LogicalOperatorType::LOGICAL_VACUUM: {
+		auto &info = (VacuumInfo &)*op.info;
+		if (!info.has_table) {
+			return make_unique<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(move(op.info)),
+			                                   op.estimated_cardinality);
+		}
+		info.bound_ref->get->ResolveOperatorTypes();
+		auto child = CreatePlan(*info.bound_ref->get);
+		auto result = make_unique<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(move(op.info)),
+		                                          op.estimated_cardinality);
+		result->children.push_back(move(child));
+		return move(result);
+	}
 	case LogicalOperatorType::LOGICAL_LOAD:
 		return make_unique<PhysicalLoad>(unique_ptr_cast<ParseInfo, LoadInfo>(move(op.info)), op.estimated_cardinality);
 	default:
@@ -137503,7 +137670,7 @@ unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator
 
 
 
-#include <map>
+
 
 namespace duckdb {
 
@@ -137728,6 +137895,23 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		everything_referenced = true;
 		break;
 	}
+	case LogicalOperatorType::LOGICAL_VACUUM: {
+		auto &vacuum = (LogicalSimple &)op;
+		auto &info = (VacuumInfo &)*vacuum.info;
+		if (!info.bound_ref) {
+			break;
+		}
+
+		auto &get = (LogicalGet &)*info.bound_ref->get;
+		for (auto &col : info.columns) {
+			for (idx_t col_idx = 0; col_idx < get.names.size(); col_idx++) {
+				if (get.names[col_idx] == col) {
+					get.column_ids.push_back(col_idx);
+					break;
+				}
+			}
+		}
+	}
 	default:
 		break;
 	}
@@ -140365,60 +140549,6 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundConjun
 } // namespace duckdb
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/distinct_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-class Vector;
-
-class DistinctStatistics : public BaseStatistics {
-public:
-	DistinctStatistics();
-	explicit DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count);
-
-	//! The HLL of the table
-	unique_ptr<HyperLogLog> log;
-	//! How many values have been sampled into the HLL
-	atomic<idx_t> sample_count;
-	//! How many values have been inserted (before sampling)
-	atomic<idx_t> total_count;
-
-public:
-	void Merge(const BaseStatistics &other) override;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	void Serialize(FieldWriter &writer) const override;
-
-	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &source);
-	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
-
-	void Update(Vector &update, idx_t count);
-	void Update(VectorData &update_data, const LogicalType &ptype, idx_t count);
-
-	string ToString() const override;
-	idx_t GetCount() const;
-
-private:
-	//! For distinct statistics we sample the input to speed up insertions
-	static constexpr const double SAMPLE_RATE = 0.1;
-};
-
-} // namespace duckdb
 
 
 
@@ -155180,7 +155310,7 @@ private:
 	//! Transform a Postgres duckdb_libpgquery::T_PGImportStmt node into a PragmaStatement
 	unique_ptr<PragmaStatement> TransformImport(duckdb_libpgquery::PGNode *node);
 	unique_ptr<ExplainStatement> TransformExplain(duckdb_libpgquery::PGNode *node);
-	unique_ptr<VacuumStatement> TransformVacuum(duckdb_libpgquery::PGNode *node);
+	unique_ptr<SQLStatement> TransformVacuum(duckdb_libpgquery::PGNode *node);
 	unique_ptr<SQLStatement> TransformShow(duckdb_libpgquery::PGNode *node);
 	unique_ptr<ShowStatement> TransformShowSelect(duckdb_libpgquery::PGNode *node);
 
@@ -157356,12 +157486,12 @@ namespace duckdb {
 
 class VacuumStatement : public SQLStatement {
 public:
-	VacuumStatement();
+	explicit VacuumStatement(const VacuumOptions &options);
 
 	unique_ptr<VacuumInfo> info;
 
 protected:
-	VacuumStatement(const VacuumStatement &other) : SQLStatement(other) {};
+	VacuumStatement(const VacuumStatement &other);
 
 public:
 	unique_ptr<SQLStatement> Copy() const override;
@@ -157372,7 +157502,11 @@ public:
 
 namespace duckdb {
 
-VacuumStatement::VacuumStatement() : SQLStatement(StatementType::VACUUM_STATEMENT) {
+VacuumStatement::VacuumStatement(const VacuumOptions &options)
+    : SQLStatement(StatementType::VACUUM_STATEMENT), info(make_unique<VacuumInfo>(options)) {
+}
+
+VacuumStatement::VacuumStatement(const VacuumStatement &other) : SQLStatement(other), info(other.info->Copy()) {
 }
 
 unique_ptr<SQLStatement> VacuumStatement::Copy() const {
@@ -160976,7 +161110,6 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 	auto qname = TransformQualifiedName(stmt->name);
 
 	unique_ptr<MacroFunction> macro_func;
-	;
 
 	// function can be null here
 	if (stmt->function) {
@@ -162343,12 +162476,55 @@ unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNo
 
 namespace duckdb {
 
-unique_ptr<VacuumStatement> Transformer::TransformVacuum(duckdb_libpgquery::PGNode *node) {
+VacuumOptions ParseOptions(int options) {
+	VacuumOptions result;
+	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_VACUUM) {
+		result.vacuum = true;
+	}
+	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_ANALYZE) {
+		result.analyze = true;
+	}
+	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_VERBOSE) {
+		throw NotImplementedException("Verbose vacuum option");
+	}
+	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_FREEZE) {
+		throw NotImplementedException("Freeze vacuum option");
+	}
+	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_FULL) {
+		throw NotImplementedException("Full vacuum option");
+	}
+	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_NOWAIT) {
+		throw NotImplementedException("No Wait vacuum option");
+	}
+	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_SKIPTOAST) {
+		throw NotImplementedException("Skip Toast vacuum option");
+	}
+	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_DISABLE_PAGE_SKIPPING) {
+		throw NotImplementedException("Disable Page Skipping vacuum option");
+	}
+	return result;
+}
+
+unique_ptr<SQLStatement> Transformer::TransformVacuum(duckdb_libpgquery::PGNode *node) {
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVacuumStmt *>(node);
 	D_ASSERT(stmt);
-	(void)stmt;
-	auto result = make_unique<VacuumStatement>();
-	return result;
+
+	auto result = make_unique<VacuumStatement>(ParseOptions(stmt->options));
+
+	if (stmt->relation) {
+		result->info->ref = TransformRangeVar(stmt->relation);
+		result->info->has_table = true;
+	}
+
+	if (stmt->va_cols) {
+		D_ASSERT(result->info->has_table);
+		for (auto col_node = stmt->va_cols->head; col_node != nullptr; col_node = col_node->next) {
+			result->info->columns.emplace_back(
+			    reinterpret_cast<duckdb_libpgquery::PGValue *>(col_node->data.ptr_value)->val.str);
+		}
+	}
+
+	return move(result);
 }
 
 } // namespace duckdb
@@ -163364,35 +163540,6 @@ protected:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_tableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundTableRef {
-public:
-	explicit BoundTableRef(TableReferenceType type) : type(type) {
-	}
-	virtual ~BoundTableRef() {
-	}
-
-	//! The type of table reference
-	TableReferenceType type;
-	//! The sample options (if any)
-	unique_ptr<SampleOptions> sample;
-};
-} // namespace duckdb
 
 
 
@@ -167207,33 +167354,6 @@ struct BoundCreateFunctionInfo {
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_basetableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class TableCatalogEntry;
-
-//! Represents a TableReference to a base table in the schema
-class BoundBaseTableRef : public BoundTableRef {
-public:
-	BoundBaseTableRef(TableCatalogEntry *table, unique_ptr<LogicalOperator> get)
-	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(move(get)) {
-	}
-
-	TableCatalogEntry *table;
-	unique_ptr<LogicalOperator> get;
-};
-} // namespace duckdb
 
 
 
@@ -169300,10 +169420,27 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 
 
+
 namespace duckdb {
 
 BoundStatement Binder::Bind(VacuumStatement &stmt) {
 	BoundStatement result;
+
+	if (stmt.info->has_table) {
+		auto bound_table = Bind(*stmt.info->ref);
+		if (bound_table->type != TableReferenceType::BASE_TABLE) {
+			throw InvalidInputException("Can only vacuum/analyze base tables!");
+		}
+		stmt.info->bound_ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(move(bound_table));
+
+		auto &columns = stmt.info->columns;
+		if (columns.empty()) {
+			// Empty means ALL columns should be vacuumed/analyzed
+			auto &get = (LogicalGet &)*stmt.info->bound_ref->get;
+			columns.insert(columns.end(), get.names.begin(), get.names.end());
+		}
+	}
+
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_VACUUM, move(stmt.info));
@@ -182698,7 +182835,6 @@ private:
 
 
 
-
 namespace duckdb {
 
 DataTable::DataTable(DatabaseInstance &db, const string &schema, const string &table,
@@ -184007,6 +184143,12 @@ unique_ptr<BaseStatistics> DataTable::GetStatistics(ClientContext &context, colu
 	return column_stats[column_id]->stats->Copy();
 }
 
+void DataTable::SetStatistics(column_t column_id, const std::function<void(BaseStatistics &)> &set_fun) {
+	D_ASSERT(column_id != COLUMN_IDENTIFIER_ROW_ID);
+	lock_guard<mutex> stats_guard(stats_lock);
+	set_fun(*column_stats[column_id]->stats);
+}
+
 //===--------------------------------------------------------------------===//
 // Checkpoint
 //===--------------------------------------------------------------------===//
@@ -185520,7 +185662,7 @@ unique_ptr<BaseStatistics> DistinctStatistics::Copy() const {
 void DistinctStatistics::Merge(const BaseStatistics &other_p) {
 	BaseStatistics::Merge(other_p);
 	auto &other = (const DistinctStatistics &)other_p;
-	log->Merge(*other.log);
+	log = log->Merge(*other.log);
 	sample_count += other.sample_count;
 	total_count += other.total_count;
 }
@@ -185550,18 +185692,21 @@ unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(FieldReader &read
 	return make_unique<DistinctStatistics>(HyperLogLog::Deserialize(reader), sample_count, total_count);
 }
 
-void DistinctStatistics::Update(Vector &v, idx_t count) {
+void DistinctStatistics::Update(Vector &v, idx_t count, bool sample) {
 	VectorData vdata;
 	v.Orrify(count, vdata);
-	Update(vdata, v.GetType(), count);
+	Update(vdata, v.GetType(), count, sample);
 }
 
-void DistinctStatistics::Update(VectorData &vdata, const LogicalType &type, idx_t count) {
+void DistinctStatistics::Update(VectorData &vdata, const LogicalType &type, idx_t count, bool sample) {
 	if (count == 0) {
 		return;
 	}
+
 	total_count += count;
-	count = MinValue<idx_t>(idx_t(SAMPLE_RATE * MaxValue<idx_t>(STANDARD_VECTOR_SIZE, count)), count);
+	if (sample) {
+		count = MinValue<idx_t>(idx_t(SAMPLE_RATE * MaxValue<idx_t>(STANDARD_VECTOR_SIZE, count)), count);
+	}
 	sample_count += count;
 
 	uint64_t indices[STANDARD_VECTOR_SIZE];