duckdb 0.7.2-dev832.0 → 0.7.2-dev886.0

package/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp

@@ -10,71 +10,316 @@
 
 #include "duckdb/common/constants.hpp"
 #include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/storage/table/segment_base.hpp"
 #include "duckdb/storage/table/segment_lock.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/mutex.hpp"
+#include "duckdb/common/string_util.hpp"
 
 namespace duckdb {
 
+template <class T>
 struct SegmentNode {
 	idx_t row_start;
-	unique_ptr<SegmentBase> node;
+	unique_ptr<T> node;
 };
 
 //! The SegmentTree maintains a list of all segments of a specific column in a table, and allows searching for a segment
 //! by row number
+template <class T, bool SUPPORTS_LAZY_LOADING = false>
 class SegmentTree {
+private:
+	class SegmentIterationHelper;
+
 public:
+	explicit SegmentTree() : finished_loading(true) {
+	}
+	virtual ~SegmentTree() {
+	}
+
 	//! Locks the segment tree. All methods to the segment tree either lock the segment tree, or take an already
 	//! obtained lock.
-	SegmentLock Lock();
+	SegmentLock Lock() {
+		return SegmentLock(node_lock);
+	}
 
-	bool IsEmpty(SegmentLock &);
+	bool IsEmpty(SegmentLock &l) {
+		return GetRootSegment(l) == nullptr;
+	}
 
 	//! Gets a pointer to the first segment. Useful for scans.
-	SegmentBase *GetRootSegment();
-	SegmentBase *GetRootSegment(SegmentLock &);
+	T *GetRootSegment() {
+		auto l = Lock();
+		return GetRootSegment(l);
+	}
+
+	T *GetRootSegment(SegmentLock &l) {
+		if (nodes.empty()) {
+			LoadNextSegment(l);
+		}
+		return nodes.empty() ? nullptr : nodes[0].node.get();
+	}
 	//! Obtains ownership of the data of the segment tree
-	vector<SegmentNode> MoveSegments(SegmentLock &);
+	vector<SegmentNode<T>> MoveSegments(SegmentLock &l) {
+		LoadAllSegments(l);
+		return std::move(nodes);
+	}
 	//! Gets a pointer to the nth segment. Negative numbers start from the back.
-	SegmentBase *GetSegmentByIndex(int64_t index);
-	SegmentBase *GetSegmentByIndex(SegmentLock &, int64_t index);
+	T *GetSegmentByIndex(int64_t index) {
+		auto l = Lock();
+		return GetSegmentByIndex(l, index);
+	}
+	T *GetSegmentByIndex(SegmentLock &l, int64_t index) {
+		if (index < 0) {
+			// load all segments
+			LoadAllSegments(l);
+			index = nodes.size() + index;
+			if (index < 0) {
+				return nullptr;
+			}
+			return nodes[index].node.get();
+		} else {
+			// lazily load segments until we reach the specific segment
+			while (idx_t(index) >= nodes.size() && LoadNextSegment(l)) {
+			}
+			if (idx_t(index) >= nodes.size()) {
+				return nullptr;
+			}
+			return nodes[index].node.get();
+		}
+	}
+	//! Gets the next segment
+	T *GetNextSegment(T *segment) {
+		if (!SUPPORTS_LAZY_LOADING) {
+			return segment->Next();
+		}
+		if (finished_loading) {
+			return segment->Next();
+		}
+		auto l = Lock();
+		return GetNextSegment(l, segment);
+	}
+	T *GetNextSegment(SegmentLock &l, T *segment) {
+		if (!segment) {
+			return nullptr;
+		}
+#ifdef DEBUG
+		D_ASSERT(nodes[segment->index].node.get() == segment);
+#endif
+		return GetSegmentByIndex(l, segment->index + 1);
+	}
 
 	//! Gets a pointer to the last segment. Useful for appends.
-	SegmentBase *GetLastSegment();
-	SegmentBase *GetLastSegment(SegmentLock &);
+	T *GetLastSegment(SegmentLock &l) {
+		LoadAllSegments(l);
+		if (nodes.empty()) {
+			return nullptr;
+		}
+		return nodes.back().node.get();
+	}
 	//! Gets a pointer to a specific column segment for the given row
-	SegmentBase *GetSegment(idx_t row_number);
-	SegmentBase *GetSegment(SegmentLock &, idx_t row_number);
+	T *GetSegment(idx_t row_number) {
+		auto l = Lock();
+		return GetSegment(l, row_number);
+	}
+	T *GetSegment(SegmentLock &l, idx_t row_number) {
+		return nodes[GetSegmentIndex(l, row_number)].node.get();
+	}
 
 	//! Append a column segment to the tree
-	void AppendSegment(unique_ptr<SegmentBase> segment);
-	void AppendSegment(SegmentLock &, unique_ptr<SegmentBase> segment);
+	void AppendSegmentInternal(SegmentLock &l, unique_ptr<T> segment) {
+		D_ASSERT(segment);
+		// add the node to the list of nodes
+		if (!nodes.empty()) {
+			nodes.back().node->next = segment.get();
+		}
+		SegmentNode<T> node;
+		segment->index = nodes.size();
+		node.row_start = segment->start;
+		node.node = std::move(segment);
+		nodes.push_back(std::move(node));
+	}
+	void AppendSegment(unique_ptr<T> segment) {
+		auto l = Lock();
+		AppendSegment(l, std::move(segment));
+	}
+	void AppendSegment(SegmentLock &l, unique_ptr<T> segment) {
+		LoadAllSegments(l);
+		AppendSegmentInternal(l, std::move(segment));
+	}
 	//! Debug method, check whether the segment is in the segment tree
-	bool HasSegment(SegmentBase *segment);
-	bool HasSegment(SegmentLock &, SegmentBase *segment);
+	bool HasSegment(T *segment) {
+		auto l = Lock();
+		return HasSegment(l, segment);
+	}
+	bool HasSegment(SegmentLock &, T *segment) {
+		return segment->index < nodes.size() && nodes[segment->index].node.get() == segment;
+	}
 
 	//! Replace this tree with another tree, taking over its nodes in-place
-	void Replace(SegmentTree &other);
-	void Replace(SegmentLock &, SegmentTree &other);
+	void Replace(SegmentTree<T> &other) {
+		auto l = Lock();
+		Replace(l, other);
+	}
+	void Replace(SegmentLock &l, SegmentTree<T> &other) {
+		other.LoadAllSegments(l);
+		nodes = std::move(other.nodes);
+	}
 
 	//! Erase all segments after a specific segment
-	void EraseSegments(SegmentLock &, idx_t segment_start);
+	void EraseSegments(SegmentLock &l, idx_t segment_start) {
+		LoadAllSegments(l);
+		if (segment_start >= nodes.size() - 1) {
+			return;
+		}
+		nodes.erase(nodes.begin() + segment_start + 1, nodes.end());
+	}
 
 	//! Get the segment index of the column segment for the given row
-	idx_t GetSegmentIndex(idx_t row_number);
-	idx_t GetSegmentIndex(SegmentLock &, idx_t row_number);
-	bool TryGetSegmentIndex(SegmentLock &, idx_t row_number, idx_t &);
+	idx_t GetSegmentIndex(SegmentLock &l, idx_t row_number) {
+		idx_t segment_index;
+		if (TryGetSegmentIndex(l, row_number, segment_index)) {
+			return segment_index;
+		}
+		string error;
+		error = StringUtil::Format("Attempting to find row number \"%lld\" in %lld nodes\n", row_number, nodes.size());
+		for (idx_t i = 0; i < nodes.size(); i++) {
+			error += StringUtil::Format("Node %lld: Start %lld, Count %lld", i, nodes[i].row_start,
+			                            nodes[i].node->count.load());
+		}
+		throw InternalException("Could not find node in column segment tree!\n%s%s", error, Exception::GetStackTrace());
+	}
+
+	bool TryGetSegmentIndex(SegmentLock &l, idx_t row_number, idx_t &result) {
+		// load segments until the row number is within bounds
+		while (nodes.empty() || (row_number >= (nodes.back().row_start + nodes.back().node->count))) {
+			if (!LoadNextSegment(l)) {
+				break;
+			}
+		}
+		if (nodes.empty()) {
+			return false;
+		}
+		D_ASSERT(!nodes.empty());
+		D_ASSERT(row_number >= nodes[0].row_start);
+		D_ASSERT(row_number < nodes.back().row_start + nodes.back().node->count);
+		idx_t lower = 0;
+		idx_t upper = nodes.size() - 1;
+		// binary search to find the node
+		while (lower <= upper) {
+			idx_t index = (lower + upper) / 2;
+			D_ASSERT(index < nodes.size());
+			auto &entry = nodes[index];
+			D_ASSERT(entry.row_start == entry.node->start);
+			if (row_number < entry.row_start) {
+				upper = index - 1;
+			} else if (row_number >= entry.row_start + entry.node->count) {
+				lower = index + 1;
+			} else {
+				result = index;
+				return true;
+			}
+		}
+		return false;
+	}
 
-	void Verify(SegmentLock &);
-	void Verify();
+	void Verify(SegmentLock &) {
+#ifdef DEBUG
+		idx_t base_start = nodes.empty() ? 0 : nodes[0].node->start;
+		for (idx_t i = 0; i < nodes.size(); i++) {
+			D_ASSERT(nodes[i].row_start == nodes[i].node->start);
+			D_ASSERT(nodes[i].node->start == base_start);
+			base_start += nodes[i].node->count;
+		}
+#endif
+	}
+	void Verify() {
+#ifdef DEBUG
+		auto l = Lock();
+		Verify(l);
+#endif
+	}
+
+	SegmentIterationHelper Segments() {
+		return SegmentIterationHelper(*this);
+	}
+
+protected:
+	atomic<bool> finished_loading;
+
+	//! Load the next segment - only used when lazily loading
+	virtual unique_ptr<T> LoadSegment() {
+		return nullptr;
+	}
 
 private:
 	//! The nodes in the tree, can be binary searched
-	vector<SegmentNode> nodes;
+	vector<SegmentNode<T>> nodes;
 	//! Lock to access or modify the nodes
 	mutex node_lock;
+
+private:
+	class SegmentIterationHelper {
+	public:
+		explicit SegmentIterationHelper(SegmentTree &tree) : tree(tree) {
+		}
+
+	private:
+		SegmentTree &tree;
+
+	private:
+		class SegmentIterator {
+		public:
+			SegmentIterator(SegmentTree &tree_p, T *current_p) : tree(tree_p), current(current_p) {
+			}
+
+			SegmentTree &tree;
+			T *current;
+
+		public:
+			void Next() {
+				current = tree.GetNextSegment(current);
+			}
+
+			SegmentIterator &operator++() {
+				Next();
+				return *this;
+			}
+			bool operator!=(const SegmentIterator &other) const {
+				return current != other.current;
+			}
+			T &operator*() const {
+				D_ASSERT(current);
+				return *current;
+			}
+		};
+
+	public:
+		SegmentIterator begin() {
+			return SegmentIterator(tree, tree.GetRootSegment());
+		}
+		SegmentIterator end() {
+			return SegmentIterator(tree, nullptr);
+		}
+	};
+
+	//! Load the next segment, if there are any left to load
+	bool LoadNextSegment(SegmentLock &l) {
+		if (finished_loading) {
+			return false;
+		}
+		auto result = LoadSegment();
+		if (result) {
+			AppendSegmentInternal(l, std::move(result));
+			return true;
+		}
+		return false;
+	}
+
+	//! Load all segments, if there are any left to load
+	void LoadAllSegments(SegmentLock &l) {
+		while (LoadNextSegment(l))
+			;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/filter_pushdown.cpp

@@ -105,13 +105,7 @@ void FilterPushdown::GenerateFilters() {
 	});
 }
 
-unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
-	// unhandled type, first perform filter pushdown in its children
-	for (auto &child : op->children) {
-		FilterPushdown pushdown(optimizer);
-		child = pushdown.Rewrite(std::move(child));
-	}
-	// now push any existing filters
+unique_ptr<LogicalOperator> FilterPushdown::PushFinalFilters(unique_ptr<LogicalOperator> op) {
 	if (filters.empty()) {
 		// no filters to push
 		return op;
@@ -124,6 +118,16 @@ unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOpe
 	return std::move(filter);
 }
 
+unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
+	// unhandled type, first perform filter pushdown in its children
+	for (auto &child : op->children) {
+		FilterPushdown pushdown(optimizer);
+		child = pushdown.Rewrite(std::move(child));
+	}
+	// now push any existing filters
+	return PushFinalFilters(std::move(op));
+}
+
 void FilterPushdown::Filter::ExtractBindings() {
 	bindings.clear();
 	LogicalJoin::GetExpressionBindings(*filter, bindings);

package/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp

@@ -122,16 +122,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 	right_pushdown.GenerateFilters();
 	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
 	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	if (filters.empty()) {
-		// no filters to push
-		return op;
-	}
-	auto filter = make_unique<LogicalFilter>();
-	for (auto &f : filters) {
-		filter->expressions.push_back(std::move(f->filter));
-	}
-	filter->children.push_back(std::move(op));
-	return std::move(filter);
+	return PushFinalFilters(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp

@@ -77,7 +77,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 	}
 	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
 	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	return FinishPushdown(std::move(op));
+	return PushFinalFilters(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_single_join.cpp

@@ -23,7 +23,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSingleJoin(unique_ptr<Logica
 	}
 	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
 	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	return FinishPushdown(std::move(op));
+	return PushFinalFilters(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/expression/transform_array_access.cpp

@@ -49,6 +49,17 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			result = make_unique<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, std::move(children));
 			break;
 		}
+		case duckdb_libpgquery::T_PGFuncCall: {
+			auto func = (duckdb_libpgquery::PGFuncCall *)target;
+			auto function = TransformFuncCall(func);
+			if (function->type != ExpressionType::FUNCTION) {
+				throw ParserException("%s.%s() call must be a function", result->ToString(), function->ToString());
+			}
+			auto &f = (FunctionExpression &)*function;
+			f.children.insert(f.children.begin(), std::move(result));
+			result = std::move(function);
+			break;
+		}
 		default:
 			throw NotImplementedException("Unimplemented subscript type");
 		}

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

@@ -10,6 +10,7 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/parser/parsed_data/drop_info.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
 
@@ -99,15 +100,35 @@ unique_ptr<SQLStatement> Transformer::CreatePivotStatement(unique_ptr<SQLStateme
 unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PGSelectStmt *stmt) {
 	auto pivot = stmt->pivot;
 	auto source = TransformTableRefNode(pivot->source);
-	auto columns = TransformPivotList(pivot->columns);
 
 	auto select_node = make_unique<SelectNode>();
 	// handle the CTEs
 	if (stmt->withClause) {
 		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), select_node->cte_map);
 	}
+	if (!pivot->columns) {
+		// no pivot columns - not actually a pivot
+		select_node->from_table = std::move(source);
+		if (pivot->groups) {
+			auto groups = TransformStringList(pivot->groups);
+			GroupingSet set;
+			for (idx_t gr = 0; gr < groups.size(); gr++) {
+				auto &group = groups[gr];
+				auto colref = make_unique<ColumnRefExpression>(group);
+				select_node->select_list.push_back(colref->Copy());
+				select_node->groups.group_expressions.push_back(std::move(colref));
+				set.insert(gr);
+			}
+			select_node->groups.grouping_sets.push_back(std::move(set));
+		}
+		if (pivot->aggrs) {
+			TransformExpressionList(*pivot->aggrs, select_node->select_list);
+		}
+		return std::move(select_node);
+	}
 
 	// generate CREATE TYPE statements for each of the columns that do not have an IN list
+	auto columns = TransformPivotList(pivot->columns);
 	auto pivot_idx = PivotEntryCount();
 	for (idx_t c = 0; c < columns.size(); c++) {
 		auto &col = columns[c];
@@ -131,13 +152,17 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 
 	auto pivot_ref = make_unique<PivotRef>();
 	pivot_ref->source = std::move(source);
-	if (pivot->aggrs) {
-		TransformExpressionList(*pivot->aggrs, pivot_ref->aggregates);
+	if (pivot->unpivots) {
+		pivot_ref->unpivot_names = TransformStringList(pivot->unpivots);
 	} else {
-		if (!pivot->unpivots) {
-			throw InternalException("No unpivots and no aggrs");
+		if (pivot->aggrs) {
+			TransformExpressionList(*pivot->aggrs, pivot_ref->aggregates);
+		} else {
+			// pivot but no aggregates specified - push a count star
+			vector<unique_ptr<ParsedExpression>> children;
+			auto function = make_unique<FunctionExpression>("count_star", std::move(children));
+			pivot_ref->aggregates.push_back(std::move(function));
 		}
-		pivot_ref->unpivot_names = TransformStringList(pivot->unpivots);
 	}
 	if (pivot->groups) {
 		pivot_ref->groups = TransformStringList(pivot->groups);

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

@@ -38,10 +38,28 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 			                       "function has to be called in a FROM clause (similar to a table).",
 			                       function.function_name)));
 		}
-		// not a table function - search again without if_exists to throw the error
-		Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
-		                  function.function_name, false, error_context);
-		throw InternalException("Catalog::GetEntry for scalar function did not throw a second time");
+		// not a table function - check if the schema is set
+		if (!function.schema.empty()) {
+			// the schema is set - check if we can turn this the schema into a column ref
+			string error;
+			unique_ptr<ColumnRefExpression> colref;
+			if (function.catalog.empty()) {
+				colref = make_unique<ColumnRefExpression>(function.schema);
+			} else {
+				colref = make_unique<ColumnRefExpression>(function.schema, function.catalog);
+			}
+			auto new_colref = QualifyColumnName(*colref, error);
+			if (error.empty()) {
+				// we can! transform this into a function call on the column
+				// i.e. "x.lower()" becomes "lower(x)"
+				function.children.insert(function.children.begin(), std::move(colref));
+				function.catalog = INVALID_CATALOG;
+				function.schema = INVALID_SCHEMA;
+			}
+		}
+		// rebind the function
+		func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
+		                         function.function_name, false, error_context);
 	}
 
 	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY &&

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

@@ -56,7 +56,7 @@ static void ConstructPivots(PivotRef &ref, idx_t pivot_idx, vector<unique_ptr<Pa
 				auto &function = (FunctionExpression &)*copy;
 				// add the filter and alias to the aggregate function
 				function.filter = expr->Copy();
-				if (ref.aggregates.size() > 1) {
+				if (ref.aggregates.size() > 1 || !function.alias.empty()) {
 					// if there are multiple aggregates specified we add the name of the aggregate as well
 					function.alias = name + "_" + function.GetName();
 				} else {

package/src/duckdb/src/storage/checkpoint/table_data_reader.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/storage/checkpoint/table_data_reader.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
-
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/types/null_value.hpp"
 
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
@@ -9,9 +7,6 @@
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 
 #include "duckdb/main/database.hpp"
-#include "duckdb/main/client_context.hpp"
-
-#include "duckdb/storage/table/row_group.hpp"
 
 namespace duckdb {
 
@@ -27,12 +22,9 @@ void TableDataReader::ReadTableData() {
 	info.data->table_stats.Deserialize(reader, columns);
 
 	// deserialize each of the individual row groups
-	auto row_group_count = reader.Read<uint64_t>();
-	info.data->row_groups.reserve(row_group_count);
-	for (idx_t i = 0; i < row_group_count; i++) {
-		auto row_group_pointer = RowGroup::Deserialize(reader, columns);
-		info.data->row_groups.push_back(std::move(row_group_pointer));
-	}
+	info.data->row_group_count = reader.Read<uint64_t>();
+	info.data->block_id = reader.block->BlockId();
+	info.data->offset = reader.offset;
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/checkpoint/table_data_writer.cpp

@@ -50,13 +50,19 @@ void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, Da
 
 	// now start writing the row group pointers to disk
 	table_data_writer.Write<uint64_t>(row_group_pointers.size());
+	idx_t total_rows = 0;
 	for (auto &row_group_pointer : row_group_pointers) {
+		auto row_group_count = row_group_pointer.row_start + row_group_pointer.tuple_count;
+		if (row_group_count > total_rows) {
+			total_rows = row_group_count;
+		}
 		RowGroup::Serialize(row_group_pointer, table_data_writer);
 	}
 
 	// Pointer to the table itself goes to the metadata stream.
 	meta_data_writer.Write<block_id_t>(pointer.block_id);
 	meta_data_writer.Write<uint64_t>(pointer.offset);
+	meta_data_writer.Write<idx_t>(total_rows);
 
 	// Now we serialize indexes in the table_metadata_writer
 	std::vector<BlockPointer> index_pointers = info->indexes.SerializeIndexes(table_data_writer);

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -467,6 +467,7 @@ void CheckpointReader::ReadTableData(ClientContext &context, MetaBlockReader &re
 	TableDataReader data_reader(table_data_reader, bound_info);
 
 	data_reader.ReadTableData();
+	bound_info.data->total_rows = reader.Read<idx_t>();
 
 	// Get any indexes block info
 	idx_t num_indexes = reader.Read<idx_t>();

package/src/duckdb/src/storage/compression/numeric_constant.cpp

@@ -33,7 +33,7 @@ void ConstantFillFunction(ColumnSegment &segment, Vector &result, idx_t start_id
 	auto &nstats = segment.stats.statistics;
 
 	auto data = FlatVector::GetData<T>(result);
-	auto constant_value = NumericStats::GetMinUnsafe<T>(nstats);
+	auto constant_value = NumericStats::GetMin<T>(nstats);
 	for (idx_t i = 0; i < count; i++) {
 		data[start_idx + i] = constant_value;
 	}
@@ -71,7 +71,7 @@ void ConstantScanFunction(ColumnSegment &segment, ColumnScanState &state, idx_t
 	auto &nstats = segment.stats.statistics;
 
 	auto data = FlatVector::GetData<T>(result);
-	data[0] = NumericStats::GetMinUnsafe<T>(nstats);
+	data[0] = NumericStats::GetMin<T>(nstats);
 	result.SetVectorType(VectorType::CONSTANT_VECTOR);
 }
 

package/src/duckdb/src/storage/data_table.cpp

@@ -45,7 +45,7 @@ DataTable::DataTable(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_m
 	auto types = GetTypes();
 	this->row_groups =
 	    make_shared<RowGroupCollection>(info, TableIOManager::Get(*this).GetBlockManagerForRowData(), types, 0);
-	if (data && !data->row_groups.empty()) {
+	if (data && data->row_group_count > 0) {
 		this->row_groups->Initialize(*data);
 	} else {
 		this->row_groups->InitializeEmpty();