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

package/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp

@@ -97,10 +97,11 @@ public:
 };
 
 struct BindCastInput {
-	DUCKDB_API BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, optional_ptr<ClientContext> context);
+	DUCKDB_API BindCastInput(CastFunctionSet &function_set, optional_ptr<BindCastInfo> info,
+	                         optional_ptr<ClientContext> context);
 
 	CastFunctionSet &function_set;
-	BindCastInfo *info;
+	optional_ptr<BindCastInfo> info;
 	optional_ptr<ClientContext> context;
 
 public:

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -205,6 +205,10 @@ struct LevenshteinFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct DamerauLevenshteinFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct JaccardFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

package/src/duckdb/src/include/duckdb/main/client_config.hpp

@@ -77,6 +77,8 @@ struct ClientConfig {
 	//! Maximum bits allowed for using a perfect hash table (i.e. the perfect HT can hold up to 2^perfect_ht_threshold
 	//! elements)
 	idx_t perfect_ht_threshold = 12;
+	//! The maximum number of rows to accumulate before sorting ordered aggregates.
+	idx_t ordered_aggregate_threshold = (idx_t(1) << 18);
 
 	//! Callback to create a progress bar display
 	progress_bar_display_create_func_t display_create_func = nullptr;
@@ -90,6 +92,9 @@ struct ClientConfig {
 	//! The maximum amount of pivot columns
 	idx_t pivot_limit = 100000;
 
+	//! Whether or not the "/" division operator defaults to integer division or floating point division
+	bool integer_division = false;
+
 	//! Generic options
 	case_insensitive_map_t<Value> set_variables;
 

package/src/duckdb/src/include/duckdb/main/database_manager.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/atomic.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -35,7 +36,7 @@ public:
 
 	void InitializeSystemCatalog();
 	//! Get an attached database with the given name
-	AttachedDatabase *GetDatabase(ClientContext &context, const string &name);
+	optional_ptr<AttachedDatabase> GetDatabase(ClientContext &context, const string &name);
 	//! Add a new attached database to the database manager
 	void AddDatabase(ClientContext &context, unique_ptr<AttachedDatabase> db);
 	void DetachDatabase(ClientContext &context, const string &name, bool if_exists);
@@ -43,8 +44,8 @@ public:
 	Catalog &GetSystemCatalog();
 	static const string &GetDefaultDatabase(ClientContext &context);
 
-	AttachedDatabase *GetDatabaseFromPath(ClientContext &context, const string &path);
-	vector<AttachedDatabase *> GetDatabases(ClientContext &context);
+	optional_ptr<AttachedDatabase> GetDatabaseFromPath(ClientContext &context, const string &path);
+	vector<optional_ptr<AttachedDatabase>> GetDatabases(ClientContext &context);
 
 	transaction_t GetNewQueryNumber() {
 		return current_query_number++;

package/src/duckdb/src/include/duckdb/main/query_result.hpp

@@ -131,7 +131,8 @@ private:
 	//! The row-based query result iterator. Invoking the
 	class QueryResultIterator {
 	public:
-		explicit QueryResultIterator(QueryResult *result_p) : current_row(*this, 0), result(result_p), base_row(0) {
+		explicit QueryResultIterator(optional_ptr<QueryResult> result_p)
+		    : current_row(*this, 0), result(result_p), base_row(0) {
 			if (result) {
 				chunk = shared_ptr<DataChunk>(result->Fetch().release());
 				if (!chunk) {
@@ -142,7 +143,7 @@ private:
 
 		QueryResultRow current_row;
 		shared_ptr<DataChunk> chunk;
-		QueryResult *result;
+		optional_ptr<QueryResult> result;
 		idx_t base_row;
 
 	public:

package/src/duckdb/src/include/duckdb/main/settings.hpp

@@ -65,6 +65,15 @@ struct DebugForceNoCrossProduct {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct OrderedAggregateThreshold {
+	static constexpr const char *Name = "ordered_aggregate_threshold";
+	static constexpr const char *Description = "the number of rows to accumulate before sorting, used for tuning";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct DebugWindowMode {
 	static constexpr const char *Name = "debug_window_mode";
 	static constexpr const char *Description = "DEBUG SETTING: switch window mode to use";
@@ -270,6 +279,16 @@ struct HomeDirectorySetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct IntegerDivisionSetting {
+	static constexpr const char *Name = "integer_division";
+	static constexpr const char *Description =
+	    "Whether or not the / operator defaults to integer division, or to floating point division";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct LogQueryPathSetting {
 	static constexpr const char *Name = "log_query_path";
 	static constexpr const char *Description =

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

@@ -52,14 +52,14 @@ public:
 	// &pushed_filters);
 
 private:
-	FilterResult AddFilter(Expression *expr);
-	FilterResult AddBoundComparisonFilter(Expression *expr);
+	FilterResult AddFilter(Expression &expr);
+	FilterResult AddBoundComparisonFilter(Expression &expr);
 	FilterResult AddTransitiveFilters(BoundComparisonExpression &comparison);
-	unique_ptr<Expression> FindTransitiveFilter(Expression *expr);
+	unique_ptr<Expression> FindTransitiveFilter(Expression &expr);
 	// unordered_map<idx_t, std::pair<Value *, Value *>>
 	// FindZonemapChecks(vector<idx_t> &column_ids, unordered_set<idx_t> &not_constants, Expression *filter);
-	Expression *GetNode(Expression *expr);
-	idx_t GetEquivalenceSet(Expression *expr);
+	Expression &GetNode(Expression &expr);
+	idx_t GetEquivalenceSet(Expression &expr);
 	FilterResult AddConstantComparison(vector<ExpressionValueInformation> &info_list, ExpressionValueInformation info);
 	//
 	//	//! Functions used to push and generate OR Filters
@@ -97,9 +97,9 @@ private:
 	vector<unique_ptr<Expression>> remaining_filters;
 
 	expression_map_t<unique_ptr<Expression>> stored_expressions;
-	unordered_map<Expression *, idx_t> equivalence_set_map;
+	expression_map_t<idx_t> equivalence_set_map;
 	unordered_map<idx_t, vector<ExpressionValueInformation>> constant_values;
-	unordered_map<idx_t, vector<Expression *>> equivalence_map;
+	unordered_map<idx_t, vector<reference<Expression>>> equivalence_map;
 	idx_t set_index = 0;
 	//
 	//	//! Structures used for OR Filters

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/parser/parser.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/parser/query_node.hpp"
 #include "duckdb/parser/column_list.hpp"
 #include "duckdb/parser/simplified_token.hpp"
+#include "duckdb/parser/parser_options.hpp"
 
 namespace duckdb_libpgquery {
 struct PGNode;
@@ -20,13 +21,6 @@ struct PGList;
 } // namespace duckdb_libpgquery
 
 namespace duckdb {
-class ParserExtension;
-
-struct ParserOptions {
-	bool preserve_identifier_case = true;
-	idx_t max_expression_depth = 1000;
-	const vector<ParserExtension> *extensions = nullptr;
-};
 
 //! The parser is responsible for parsing the query and converting it into a set
 //! of parsed statements. The parsed statements can then be converted into a

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

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parser_options.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+class ParserExtension;
+
+struct ParserOptions {
+	bool preserve_identifier_case = true;
+	bool integer_division = false;
+	idx_t max_expression_depth = 1000;
+	const vector<ParserExtension> *extensions = nullptr;
+};
+
+} // namespace duckdb

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

@@ -33,6 +33,7 @@ struct CommonTableExpressionInfo;
 struct GroupingExpressionMap;
 class OnConflictInfo;
 class UpdateSetInfo;
+struct ParserOptions;
 struct PivotColumn;
 
 //! The transformer class is responsible for transforming the internal Postgres
@@ -47,7 +48,7 @@ class Transformer {
 	};
 
 public:
-	explicit Transformer(idx_t max_expression_depth_p);
+	explicit Transformer(ParserOptions &options);
 	explicit Transformer(Transformer *parent);
 	~Transformer();
 
@@ -61,7 +62,8 @@ public:
 
 private:
 	Transformer *parent;
-	idx_t max_expression_depth;
+	//! Parser options
+	ParserOptions &options;
 	//! The current prepared statement parameter index
 	idx_t prepared_statement_parameter_index = 0;
 	//! Map from named parameter to parameter index;
@@ -292,7 +294,7 @@ private:
 	                                                  CommonTableExpressionInfo &info);
 
 	unique_ptr<ParsedExpression> TransformUnaryOperator(const string &op, unique_ptr<ParsedExpression> child);
-	unique_ptr<ParsedExpression> TransformBinaryOperator(const string &op, unique_ptr<ParsedExpression> left,
+	unique_ptr<ParsedExpression> TransformBinaryOperator(string op, unique_ptr<ParsedExpression> left,
 	                                                     unique_ptr<ParsedExpression> right);
 	//===--------------------------------------------------------------------===//
 	// TableRef transform

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;
 };