duckdb 0.7.2-dev1803.0 → 0.7.2-dev1867.0

package/src/duckdb/src/include/duckdb/optimizer/matcher/expression_matcher.hpp

@@ -27,7 +27,7 @@ public:
 
 	//! Checks if the given expression matches this ExpressionMatcher. If it does, the expression is appended to the
 	//! bindings list and true is returned. Otherwise, false is returned.
-	virtual bool Match(Expression *expr, vector<Expression *> &bindings);
+	virtual bool Match(Expression &expr, vector<reference<Expression>> &bindings);
 
 	//! The ExpressionClass of the to-be-matched expression. ExpressionClass::INVALID for ANY.
 	ExpressionClass expr_class;
@@ -40,14 +40,14 @@ public:
 //! The ExpressionEqualityMatcher matches on equality with another (given) expression
 class ExpressionEqualityMatcher : public ExpressionMatcher {
 public:
-	explicit ExpressionEqualityMatcher(Expression *expr)
+	explicit ExpressionEqualityMatcher(Expression &expr)
 	    : ExpressionMatcher(ExpressionClass::INVALID), expression(expr) {
 	}
 
-	bool Match(Expression *expr, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 
 private:
-	Expression *expression;
+	const Expression &expression;
 };
 
 class ConstantExpressionMatcher : public ExpressionMatcher {
@@ -61,7 +61,7 @@ public:
 	CaseExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CASE) {
 	}
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class ComparisonExpressionMatcher : public ExpressionMatcher {
@@ -74,7 +74,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class CastExpressionMatcher : public ExpressionMatcher {
@@ -84,7 +84,7 @@ public:
 	//! The matcher for the child expressions
 	unique_ptr<ExpressionMatcher> matcher;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class InClauseExpressionMatcher : public ExpressionMatcher {
@@ -96,7 +96,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class ConjunctionExpressionMatcher : public ExpressionMatcher {
@@ -109,7 +109,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class FunctionExpressionMatcher : public ExpressionMatcher {
@@ -123,7 +123,7 @@ public:
 	//! The function name to match
 	unique_ptr<FunctionMatcher> function;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 //! The FoldableConstant matcher matches any expression that is foldable into a constant by the ExpressionExecutor (i.e.
@@ -133,7 +133,7 @@ public:
 	FoldableConstantMatcher() : ExpressionMatcher(ExpressionClass::INVALID) {
 	}
 
-	bool Match(Expression *expr, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/matcher/set_matcher.hpp

@@ -29,8 +29,8 @@ public:
 
 	/* The double {{}} in the intializer for excluded_entries is intentional, workaround for bug in gcc-4.9 */
 	template <class T, class MATCHER>
-	static bool MatchRecursive(vector<unique_ptr<MATCHER>> &matchers, vector<T *> &entries, vector<T *> &bindings,
-	                           unordered_set<idx_t> excluded_entries, idx_t m_idx = 0) {
+	static bool MatchRecursive(vector<unique_ptr<MATCHER>> &matchers, vector<reference<T>> &entries,
+	                           vector<reference<T>> &bindings, unordered_set<idx_t> excluded_entries, idx_t m_idx = 0) {
 		if (m_idx == matchers.size()) {
 			// matched all matchers!
 			return true;
@@ -65,8 +65,8 @@ public:
 	}
 
 	template <class T, class MATCHER>
-	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<T *> &entries, vector<T *> &bindings,
-	                  Policy policy) {
+	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<reference<T>> &entries,
+	                  vector<reference<T>> &bindings, Policy policy) {
 		if (policy == Policy::ORDERED) {
 			// ordered policy, count has to match
 			if (matchers.size() != entries.size()) {
@@ -100,12 +100,12 @@ public:
 	}
 
 	template <class T, class MATCHER>
-	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<unique_ptr<T>> &entries, vector<T *> &bindings,
-	                  Policy policy) {
+	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<unique_ptr<T>> &entries,
+	                  vector<reference<T>> &bindings, Policy policy) {
 		// convert vector of unique_ptr to vector of normal pointers
-		vector<T *> ptr_entries;
+		vector<reference<T>> ptr_entries;
 		for (auto &entry : entries) {
-			ptr_entries.push_back(entry.get());
+			ptr_entries.push_back(*entry);
 		}
 		// then just call the normal match function
 		return Match(matchers, ptr_entries, bindings, policy);

package/src/duckdb/src/include/duckdb/optimizer/rule/arithmetic_simplification.hpp

@@ -18,7 +18,7 @@ class ArithmeticSimplificationRule : public Rule {
 public:
 	explicit ArithmeticSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/case_simplification.hpp

@@ -17,7 +17,7 @@ class CaseSimplificationRule : public Rule {
 public:
 	explicit CaseSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/comparison_simplification.hpp

@@ -17,7 +17,7 @@ class ComparisonSimplificationRule : public Rule {
 public:
 	explicit ComparisonSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/conjunction_simplification.hpp

@@ -17,10 +17,10 @@ class ConjunctionSimplificationRule : public Rule {
 public:
 	explicit ConjunctionSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
-	unique_ptr<Expression> RemoveExpression(BoundConjunctionExpression &conj, Expression *expr);
+	unique_ptr<Expression> RemoveExpression(BoundConjunctionExpression &conj, const Expression &expr);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/rule/constant_folding.hpp

@@ -17,7 +17,7 @@ class ConstantFoldingRule : public Rule {
 public:
 	explicit ConstantFoldingRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/date_part_simplification.hpp

@@ -18,7 +18,7 @@ class DatePartSimplificationRule : public Rule {
 public:
 	explicit DatePartSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/distributivity.hpp

@@ -18,7 +18,7 @@ class DistributivityRule : public Rule {
 public:
 	explicit DistributivityRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
 private:

package/src/duckdb/src/include/duckdb/optimizer/rule/empty_needle_removal.hpp

@@ -18,7 +18,7 @@ class EmptyNeedleRemovalRule : public Rule {
 public:
 	explicit EmptyNeedleRemovalRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/enum_comparison.hpp

@@ -17,7 +17,7 @@ class EnumComparisonRule : public Rule {
 public:
 	explicit EnumComparisonRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/equal_or_null_simplification.hpp

@@ -18,7 +18,7 @@ class EqualOrNullSimplification : public Rule {
 public:
 	explicit EqualOrNullSimplification(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/in_clause_simplification.hpp

@@ -17,7 +17,7 @@ class InClauseSimplificationRule : public Rule {
 public:
 	explicit InClauseSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/like_optimizations.hpp

@@ -18,7 +18,7 @@ class LikeOptimizationRule : public Rule {
 public:
 	explicit LikeOptimizationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
 	unique_ptr<Expression> ApplyRule(BoundFunctionExpression &expr, ScalarFunction function, string pattern,

package/src/duckdb/src/include/duckdb/optimizer/rule/move_constants.hpp

@@ -18,7 +18,7 @@ class MoveConstantsRule : public Rule {
 public:
 	explicit MoveConstantsRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp

@@ -17,7 +17,7 @@ class OrderedAggregateOptimizer : public Rule {
 public:
 	explicit OrderedAggregateOptimizer(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };
 

package/src/duckdb/src/include/duckdb/optimizer/rule/regex_optimizations.hpp

@@ -17,7 +17,7 @@ class RegexOptimizationRule : public Rule {
 public:
 	explicit RegexOptimizationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
 	unique_ptr<Expression> ApplyRule(BoundFunctionExpression *expr, ScalarFunction function, string pattern,

package/src/duckdb/src/include/duckdb/optimizer/rule.hpp

@@ -29,8 +29,8 @@ public:
 	unique_ptr<ExpressionMatcher> root;
 
 	ClientContext &GetContext() const;
-	virtual unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &fixed_point,
-	                                     bool is_root) = 0;
+	virtual unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
+	                                     bool &fixed_point, bool is_root) = 0;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/base_expression.hpp

@@ -73,7 +73,7 @@ public:
 	//! Returns true if this expression is equal to another expression
 	virtual bool Equals(const BaseExpression *other) const;
 
-	static bool Equals(BaseExpression *left, BaseExpression *right) {
+	static bool Equals(const BaseExpression *left, const BaseExpression *right) {
 		if (left == right) {
 			return true;
 		}

package/src/duckdb/src/include/duckdb/parser/expression_map.hpp

@@ -11,25 +11,38 @@
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/parser/base_expression.hpp"
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/planner/expression.hpp"
 
 namespace duckdb {
 class Expression;
 
+template <class T>
 struct ExpressionHashFunction {
-	uint64_t operator()(const BaseExpression *const &expr) const {
-		return (uint64_t)expr->Hash();
+	uint64_t operator()(const reference<T> &expr) const {
+		return (uint64_t)expr.get().Hash();
 	}
 };
 
+template <class T>
 struct ExpressionEquality {
-	bool operator()(const BaseExpression *const &a, const BaseExpression *const &b) const {
-		return a->Equals(b);
+	bool operator()(const reference<T> &a, const reference<T> &b) const {
+		return a.get().Equals(&b.get());
 	}
 };
 
 template <typename T>
-using expression_map_t = unordered_map<BaseExpression *, T, ExpressionHashFunction, ExpressionEquality>;
+using expression_map_t =
+    unordered_map<reference<Expression>, T, ExpressionHashFunction<Expression>, ExpressionEquality<Expression>>;
 
-using expression_set_t = unordered_set<BaseExpression *, ExpressionHashFunction, ExpressionEquality>;
+using expression_set_t =
+    unordered_set<reference<Expression>, ExpressionHashFunction<Expression>, ExpressionEquality<Expression>>;
+
+template <typename T>
+using parsed_expression_map_t = unordered_map<reference<ParsedExpression>, T, ExpressionHashFunction<ParsedExpression>,
+                                              ExpressionEquality<ParsedExpression>>;
+
+using parsed_expression_set_t = unordered_set<reference<ParsedExpression>, ExpressionHashFunction<ParsedExpression>,
+                                              ExpressionEquality<ParsedExpression>>;
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression_util.hpp

@@ -28,7 +28,7 @@ public:
 private:
 	template <class T>
 	static bool ExpressionListEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b);
-	template <class T>
+	template <class T, class EXPRESSION_MAP>
 	static bool ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b);
 };
 

package/src/duckdb/src/include/duckdb/planner/expression.hpp

@@ -48,8 +48,11 @@ public:
 		return return_type == ((Expression *)other)->return_type;
 	}
 
-	static bool Equals(Expression *left, Expression *right) {
-		return BaseExpression::Equals((BaseExpression *)left, (BaseExpression *)right);
+	static bool Equals(const Expression *left, const Expression *right) {
+		return BaseExpression::Equals((const BaseExpression *)left, (const BaseExpression *)right);
+	}
+	static bool Equals(const Expression &left, const Expression &right) {
+		return left.Equals(&right);
 	}
 	//! Create a copy of this expression
 	virtual unique_ptr<Expression> Copy() = 0;

package/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp

@@ -19,7 +19,7 @@ class WindowExpression;
 class BoundSelectNode;
 
 struct BoundGroupInformation {
-	expression_map_t<idx_t> map;
+	parsed_expression_map_t<idx_t> map;
 	case_insensitive_map_t<idx_t> alias_map;
 };
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/order_binder.hpp

@@ -22,9 +22,9 @@ class SelectNode;
 class OrderBinder {
 public:
 	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);
 	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);
 
 public:
 	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> expr);
@@ -51,7 +51,7 @@ private:
 	idx_t max_count;
 	vector<unique_ptr<ParsedExpression>> *extra_list;
 	case_insensitive_map_t<idx_t> &alias_map;
-	expression_map_t<idx_t> &projection_map;
+	parsed_expression_map_t<idx_t> &projection_map;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp

@@ -26,8 +26,7 @@ struct BufferPoolReservation {
 	idx_t size {0};
 	BufferPool &pool;
 
-	BufferPoolReservation(BufferPool &pool) : pool(pool) {
-	}
+	BufferPoolReservation(BufferPool &pool);
 	BufferPoolReservation(const BufferPoolReservation &) = delete;
 	BufferPoolReservation &operator=(const BufferPoolReservation &) = delete;
 
@@ -55,6 +54,7 @@ class BlockHandle {
 	friend struct BufferEvictionNode;
 	friend class BufferHandle;
 	friend class BufferManager;
+	friend class StandardBufferManager;
 	friend class BufferPool;
 
 public:
@@ -70,6 +70,14 @@ public:
 		return block_id;
 	}
 
+	void ResizeBuffer(idx_t block_size, int64_t memory_delta) {
+		D_ASSERT(buffer);
+		// resize and adjust current memory
+		buffer->Resize(block_size);
+		memory_usage += memory_delta;
+		D_ASSERT(memory_usage == buffer->AllocSize());
+	}
+
 	int32_t Readers() const {
 		return readers;
 	}

package/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp

@@ -30,6 +30,7 @@ class BufferPool {
 	friend class BlockHandle;
 	friend class BlockManager;
 	friend class BufferManager;
+	friend class StandardBufferManager;
 
 public:
 	explicit BufferPool(idx_t maximum_memory);