duckdb 0.7.2-dev1803.0 → 0.7.2-dev1898.0

package/src/duckdb/src/planner/binder/query_node/bind_setop_node.cpp

@@ -13,7 +13,7 @@
 namespace duckdb {
 
 static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &aliases,
-                          expression_map_t<idx_t> &expressions, const vector<idx_t> &reorder_idx) {
+                          parsed_expression_map_t<idx_t> &expressions, const vector<idx_t> &reorder_idx) {
 	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
 		// setop, recurse
 		auto &setop = node.Cast<BoundSetOperationNode>();
@@ -66,16 +66,16 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
 				aliases[name] = index;
 			}
 			// now check if the node is already in the set of expressions
-			auto expr_entry = expressions.find(expr.get());
+			auto expr_entry = expressions.find(*expr);
 			if (expr_entry != expressions.end()) {
 				// the node is in there
 				// repeat the same as with the alias: if there is an ambiguity we insert "-1"
 				if (expr_entry->second != index) {
-					expressions[expr.get()] = DConstants::INVALID_INDEX;
+					expressions[*expr] = DConstants::INVALID_INDEX;
 				}
 			} else {
 				// not in there yet, just place it in there
-				expressions[expr.get()] = index;
+				expressions[*expr] = index;
 			}
 		}
 	}
@@ -240,7 +240,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 		// we recursively visit the children of this node to extract aliases and expressions that can be referenced
 		// in the ORDER BY
 		case_insensitive_map_t<idx_t> alias_map;
-		expression_map_t<idx_t> expression_map;
+		parsed_expression_map_t<idx_t> expression_map;
 
 		if (result->setop_type == SetOperationType::UNION_BY_NAME) {
 			GatherAliases(*result->left, alias_map, expression_map, result->left_reorder_idx);

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

@@ -297,10 +297,10 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		auto type_dependency = LogicalType::GetCatalog(column.Type());
 		if (type_dependency) {
 			// Only if the USER comes from a create type
-			result->dependencies.AddDependency(type_dependency);
+			result->dependencies.AddDependency(*type_dependency);
 		}
 	}
-	result->dependencies.VerifyDependencies(schema->catalog, result->Base().table);
+	result->dependencies.VerifyDependencies(*schema->catalog, result->Base().table);
 	properties.allow_stream_result = false;
 	return result;
 }

package/src/duckdb/src/planner/expression_binder/base_select_binder.cpp

@@ -56,14 +56,14 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	}
 	// no alias reference found
 	// check the list of group columns for a match
-	auto entry = info.map.find(&expr);
+	auto entry = info.map.find(expr);
 	if (entry != info.map.end()) {
 		return entry->second;
 	}
 #ifdef DEBUG
 	for (auto entry : info.map) {
-		D_ASSERT(!entry.first->Equals(&expr));
-		D_ASSERT(!expr.Equals(entry.first));
+		D_ASSERT(!entry.first.get().Equals(&expr));
+		D_ASSERT(!expr.Equals(&entry.first.get()));
 	}
 #endif
 	return DConstants::INVALID_INDEX;
@@ -77,7 +77,7 @@ BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_pt
 	}
 	// binding failed
 	// check in the alias map
-	auto &colref = (ColumnRefExpression &)**expr_ptr;
+	auto &colref = (*expr_ptr)->Cast<ColumnRefExpression>();
 	if (!colref.IsQualified()) {
 		auto alias_entry = alias_map.find(colref.column_names[0]);
 		if (alias_entry != alias_map.end()) {

package/src/duckdb/src/planner/expression_binder/order_binder.cpp

@@ -13,12 +13,12 @@
 namespace duckdb {
 
 OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
-                         expression_map_t<idx_t> &projection_map, idx_t max_count)
+                         parsed_expression_map_t<idx_t> &projection_map, idx_t max_count)
     : binders(std::move(binders)), projection_index(projection_index), max_count(max_count), extra_list(nullptr),
       alias_map(alias_map), projection_map(projection_map) {
 }
 OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-                         case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map)
+                         case_insensitive_map_t<idx_t> &alias_map, parsed_expression_map_t<idx_t> &projection_map)
     : binders(std::move(binders)), projection_index(projection_index), alias_map(alias_map),
       projection_map(projection_map) {
 	this->max_count = node.select_list.size();
@@ -111,7 +111,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		ExpressionBinder::QualifyColumnNames(*binder, expr);
 	}
 	// first check if the ORDER BY clause already points to an entry in the projection list
-	auto entry = projection_map.find(expr.get());
+	auto entry = projection_map.find(*expr);
 	if (entry != projection_map.end()) {
 		if (entry->second == DConstants::INVALID_INDEX) {
 			throw BinderException("Ambiguous reference to column");

package/src/duckdb/src/storage/buffer/block_handle.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/storage/block_manager.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
 #include "duckdb/common/file_buffer.hpp"
 
 namespace duckdb {
@@ -38,7 +39,7 @@ BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions
 	} else {
 		D_ASSERT(memory_charge.size == 0);
 	}
-	buffer_manager.buffer_pool.PurgeQueue();
+	buffer_manager.GetBufferPool().PurgeQueue();
 	block_manager.UnregisterBlock(block_id, can_destroy);
 }
 
@@ -116,7 +117,7 @@ bool BlockHandle::CanUnload() {
 		// there are active readers
 		return false;
 	}
-	if (block_id >= MAXIMUM_BLOCK && !can_destroy && block_manager.buffer_manager.temp_directory.empty()) {
+	if (block_id >= MAXIMUM_BLOCK && !can_destroy && !block_manager.buffer_manager.HasTemporaryDirectory()) {
 		// in order to unload this block we need to write it to a temporary buffer
 		// however, no temporary directory is specified!
 		// hence we cannot unload the block

package/src/duckdb/src/storage/buffer/block_manager.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/storage/block_manager.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
 
 namespace duckdb {
 
@@ -62,7 +64,7 @@ shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, s
 	// persist the new block to disk
 	Write(*new_block->buffer, block_id);
 
-	buffer_manager.buffer_pool.AddToEvictionQueue(new_block);
+	buffer_manager.GetBufferPool().AddToEvictionQueue(new_block);
 
 	return new_block;
 }

package/src/duckdb/src/storage/buffer/buffer_handle.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/storage/buffer/buffer_handle.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp

@@ -3,6 +3,9 @@
 
 namespace duckdb {
 
+BufferPoolReservation::BufferPoolReservation(BufferPool &pool) : pool(pool) {
+}
+
 BufferPoolReservation::BufferPoolReservation(BufferPoolReservation &&src) noexcept : pool(src.pool) {
 	size = src.size;
 	src.size = 0;