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

package/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp

@@ -14,7 +14,7 @@ ArithmeticSimplificationRule::ArithmeticSimplificationRule(ExpressionRewriter &r
 	op->matchers.push_back(make_uniq<ExpressionMatcher>());
 	op->policy = SetMatcher::Policy::SOME;
 	// we only match on simple arithmetic expressions (+, -, *, /)
-	op->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*", "/"});
+	op->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*", "//"});
 	// and only with numeric results
 	op->type = make_uniq<IntegerTypeMatcher>();
 	op->matchers[0]->type = make_uniq<IntegerTypeMatcher>();
@@ -22,10 +22,10 @@ ArithmeticSimplificationRule::ArithmeticSimplificationRule(ExpressionRewriter &r
 	root = std::move(op);
 }
 
-unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                            bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
-	auto &constant = bindings[1]->Cast<BoundConstantExpression>();
+	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
+	auto &constant = bindings[1].get().Cast<BoundConstantExpression>();
 	int constant_child = root.children[0].get() == &constant ? 0 : 1;
 	D_ASSERT(root.children.size() == 2);
 	(void)root;
@@ -55,8 +55,7 @@ unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op,
 			return ExpressionRewriter::ConstantOrNull(std::move(root.children[1 - constant_child]),
 			                                          Value::Numeric(root.return_type, 0));
 		}
-	} else {
-		D_ASSERT(func_name == "/");
+	} else if (func_name == "//") {
 		if (constant_child == 1) {
 			if (constant.value == 1) {
 				// divide by 1, replace with non-constant child
@@ -66,6 +65,8 @@ unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op,
 				return make_uniq<BoundConstantExpression>(Value(root.return_type));
 			}
 		}
+	} else {
+		throw InternalException("Unrecognized function name in ArithmeticSimplificationRule");
 	}
 	return nullptr;
 }

package/src/duckdb/src/optimizer/rule/case_simplification.cpp

@@ -11,9 +11,9 @@ CaseSimplificationRule::CaseSimplificationRule(ExpressionRewriter &rewriter) : R
 	root = std::move(op);
 }
 
-unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                      bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundCaseExpression>();
+	auto &root = bindings[0].get().Cast<BoundCaseExpression>();
 	for (idx_t i = 0; i < root.case_checks.size(); i++) {
 		auto &case_check = root.case_checks[i];
 		if (case_check.when_expr->IsFoldable()) {

package/src/duckdb/src/optimizer/rule/comparison_simplification.cpp

@@ -14,18 +14,17 @@ ComparisonSimplificationRule::ComparisonSimplificationRule(ExpressionRewriter &r
 	root = std::move(op);
 }
 
-unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                            bool &changes_made, bool is_root) {
-	D_ASSERT(bindings[0]->expression_class == ExpressionClass::BOUND_COMPARISON);
-	auto &expr = bindings[0]->Cast<BoundComparisonExpression>();
-	auto constant_expr = bindings[1];
-	bool column_ref_left = expr.left.get() != constant_expr;
+	auto &expr = bindings[0].get().Cast<BoundComparisonExpression>();
+	auto &constant_expr = bindings[1].get();
+	bool column_ref_left = expr.left.get() != &constant_expr;
 	auto column_ref_expr = !column_ref_left ? expr.right.get() : expr.left.get();
 	// the constant_expr is a scalar expression that we have to fold
 	// use an ExpressionExecutor to execute the expression
-	D_ASSERT(constant_expr->IsFoldable());
+	D_ASSERT(constant_expr.IsFoldable());
 	Value constant_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), *constant_expr, constant_value)) {
+	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), constant_expr, constant_value)) {
 		return nullptr;
 	}
 	if (constant_value.IsNull() && !(expr.type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||

package/src/duckdb/src/optimizer/rule/conjunction_simplification.cpp

@@ -15,9 +15,9 @@ ConjunctionSimplificationRule::ConjunctionSimplificationRule(ExpressionRewriter
 }
 
 unique_ptr<Expression> ConjunctionSimplificationRule::RemoveExpression(BoundConjunctionExpression &conj,
-                                                                       Expression *expr) {
+                                                                       const Expression &expr) {
 	for (idx_t i = 0; i < conj.children.size(); i++) {
-		if (conj.children[i].get() == expr) {
+		if (conj.children[i].get() == &expr) {
 			// erase the expression
 			conj.children.erase(conj.children.begin() + i);
 			break;
@@ -30,15 +30,16 @@ unique_ptr<Expression> ConjunctionSimplificationRule::RemoveExpression(BoundConj
 	return nullptr;
 }
 
-unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                            bool &changes_made, bool is_root) {
-	auto &conjunction = bindings[0]->Cast<BoundConjunctionExpression>();
-	auto constant_expr = bindings[1];
+unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op,
+                                                            vector<reference<Expression>> &bindings, bool &changes_made,
+                                                            bool is_root) {
+	auto &conjunction = bindings[0].get().Cast<BoundConjunctionExpression>();
+	auto &constant_expr = bindings[1].get();
 	// the constant_expr is a scalar expression that we have to fold
 	// use an ExpressionExecutor to execute the expression
-	D_ASSERT(constant_expr->IsFoldable());
+	D_ASSERT(constant_expr.IsFoldable());
 	Value constant_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), *constant_expr, constant_value)) {
+	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), constant_expr, constant_value)) {
 		return nullptr;
 	}
 	constant_value = constant_value.DefaultCastAs(LogicalType::BOOLEAN);

package/src/duckdb/src/optimizer/rule/constant_folding.cpp

@@ -10,9 +10,9 @@ namespace duckdb {
 //! The ConstantFoldingExpressionMatcher matches on any scalar expression (i.e. Expression::IsFoldable is true)
 class ConstantFoldingExpressionMatcher : public FoldableConstantMatcher {
 public:
-	bool Match(Expression *expr, vector<Expression *> &bindings) override {
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override {
 		// we also do not match on ConstantExpressions, because we cannot fold those any further
-		if (expr->type == ExpressionType::VALUE_CONSTANT) {
+		if (expr.type == ExpressionType::VALUE_CONSTANT) {
 			return false;
 		}
 		return FoldableConstantMatcher::Match(expr, bindings);
@@ -24,18 +24,18 @@ ConstantFoldingRule::ConstantFoldingRule(ExpressionRewriter &rewriter) : Rule(re
 	root = std::move(op);
 }
 
-unique_ptr<Expression> ConstantFoldingRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> ConstantFoldingRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                   bool &changes_made, bool is_root) {
-	auto root = bindings[0];
+	auto &root = bindings[0].get();
 	// the root is a scalar expression that we have to fold
-	D_ASSERT(root->IsFoldable() && root->type != ExpressionType::VALUE_CONSTANT);
+	D_ASSERT(root.IsFoldable() && root.type != ExpressionType::VALUE_CONSTANT);
 
 	// use an ExpressionExecutor to execute the expression
 	Value result_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), *root, result_value)) {
+	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), root, result_value)) {
 		return nullptr;
 	}
-	D_ASSERT(result_value.type().InternalType() == root->return_type.InternalType());
+	D_ASSERT(result_value.type().InternalType() == root.return_type.InternalType());
 	// now get the value from the result vector and insert it back into the plan as a constant expression
 	return make_uniq<BoundConstantExpression>(result_value);
 }

package/src/duckdb/src/optimizer/rule/date_part_simplification.cpp

@@ -20,10 +20,10 @@ DatePartSimplificationRule::DatePartSimplificationRule(ExpressionRewriter &rewri
 	root = std::move(func);
 }
 
-unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                          bool &changes_made, bool is_root) {
-	auto &date_part = bindings[0]->Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[1]->Cast<BoundConstantExpression>();
+	auto &date_part = bindings[0].get().Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[1].get().Cast<BoundConstantExpression>();
 	auto &constant = constant_expr.value;
 
 	if (constant.IsNull()) {

package/src/duckdb/src/optimizer/rule/distributivity.cpp

@@ -18,10 +18,10 @@ void DistributivityRule::AddExpressionSet(Expression &expr, expression_set_t &se
 	if (expr.type == ExpressionType::CONJUNCTION_AND) {
 		auto &and_expr = expr.Cast<BoundConjunctionExpression>();
 		for (auto &child : and_expr.children) {
-			set.insert(child.get());
+			set.insert(*child);
 		}
 	} else {
-		set.insert(&expr);
+		set.insert(expr);
 	}
 }
 
@@ -53,9 +53,9 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 	return result;
 }
 
-unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                  bool &changes_made, bool is_root) {
-	auto &initial_or = bindings[0]->Cast<BoundConjunctionExpression>();
+	auto &initial_or = bindings[0].get().Cast<BoundConjunctionExpression>();
 
 	// we want to find expressions that occur in each of the children of the OR
 	// i.e. (X AND A) OR (X AND B) => X occurs in all branches
@@ -88,7 +88,7 @@ unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Exp
 		D_ASSERT(initial_or.children.size() > 0);
 
 		// extract the expression from the first child of the OR
-		auto result = ExtractExpression(initial_or, 0, (Expression &)*expr);
+		auto result = ExtractExpression(initial_or, 0, expr.get());
 		// now for the subsequent expressions, simply remove the expression
 		for (idx_t i = 1; i < initial_or.children.size(); i++) {
 			ExtractExpression(initial_or, i, *result);

package/src/duckdb/src/optimizer/rule/empty_needle_removal.cpp

@@ -21,25 +21,25 @@ EmptyNeedleRemovalRule::EmptyNeedleRemovalRule(ExpressionRewriter &rewriter) : R
 	root = std::move(func);
 }
 
-unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                      bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
+	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
 	D_ASSERT(root.children.size() == 2);
-	auto prefix_expr = bindings[2];
+	auto &prefix_expr = bindings[2].get();
 
 	// the constant_expr is a scalar expression that we have to fold
-	if (!prefix_expr->IsFoldable()) {
+	if (!prefix_expr.IsFoldable()) {
 		return nullptr;
 	}
 	D_ASSERT(root.return_type.id() == LogicalTypeId::BOOLEAN);
 
-	auto prefix_value = ExpressionExecutor::EvaluateScalar(GetContext(), *prefix_expr);
+	auto prefix_value = ExpressionExecutor::EvaluateScalar(GetContext(), prefix_expr);
 
 	if (prefix_value.IsNull()) {
 		return make_uniq<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
 	}
 
-	D_ASSERT(prefix_value.type() == prefix_expr->return_type);
+	D_ASSERT(prefix_value.type() == prefix_expr.return_type);
 	auto &needle_string = StringValue::Get(prefix_value);
 
 	// PREFIX('xyz', '') is TRUE

package/src/duckdb/src/optimizer/rule/enum_comparison.cpp

@@ -44,12 +44,12 @@ bool AreMatchesPossible(LogicalType &left, LogicalType &right) {
 	}
 	return false;
 }
-unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                  bool &changes_made, bool is_root) {
 
-	auto &root = bindings[0]->Cast<BoundComparisonExpression>();
-	auto &left_child = bindings[1]->Cast<BoundCastExpression>();
-	auto &right_child = bindings[3]->Cast<BoundCastExpression>();
+	auto &root = bindings[0].get().Cast<BoundComparisonExpression>();
+	auto &left_child = bindings[1].get().Cast<BoundCastExpression>();
+	auto &right_child = bindings[3].get().Cast<BoundCastExpression>();
 
 	if (!AreMatchesPossible(left_child.child->return_type, right_child.child->return_type)) {
 		vector<unique_ptr<Expression>> children;

package/src/duckdb/src/optimizer/rule/equal_or_null_simplification.cpp

@@ -37,31 +37,30 @@ EqualOrNullSimplification::EqualOrNullSimplification(ExpressionRewriter &rewrite
 }
 
 // a=b OR (a IS NULL AND b IS NULL) to a IS NOT DISTINCT FROM b
-static unique_ptr<Expression> TryRewriteEqualOrIsNull(const Expression *equal_expr, const Expression *and_expr) {
-	if (equal_expr->type != ExpressionType::COMPARE_EQUAL || and_expr->type != ExpressionType::CONJUNCTION_AND) {
+static unique_ptr<Expression> TryRewriteEqualOrIsNull(Expression &equal_expr, Expression &and_expr) {
+	if (equal_expr.type != ExpressionType::COMPARE_EQUAL || and_expr.type != ExpressionType::CONJUNCTION_AND) {
 		return nullptr;
 	}
 
-	const auto equal_cast = (BoundComparisonExpression *)equal_expr;
-	const auto and_cast = (BoundConjunctionExpression *)and_expr;
+	auto &equal_cast = equal_expr.Cast<BoundComparisonExpression>();
+	auto &and_cast = and_expr.Cast<BoundConjunctionExpression>();
 
-	if (and_cast->children.size() != 2) {
+	if (and_cast.children.size() != 2) {
 		return nullptr;
 	}
 
 	// Make sure on the AND conjuction the relevant conditions appear
-	const auto a_exp = equal_cast->left.get();
-	const auto b_exp = equal_cast->right.get();
-	bool valid = true;
+	auto &a_exp = *equal_cast.left;
+	auto &b_exp = *equal_cast.right;
 	bool a_is_null_found = false;
 	bool b_is_null_found = false;
 
-	for (const auto &item : and_cast->children) {
-		const auto next_exp = item.get();
+	for (const auto &item : and_cast.children) {
+		auto &next_exp = *item;
 
-		if (next_exp->type == ExpressionType::OPERATOR_IS_NULL) {
-			const auto next_exp_cast = (BoundOperatorExpression *)next_exp;
-			const auto child = next_exp_cast->children[0].get();
+		if (next_exp.type == ExpressionType::OPERATOR_IS_NULL) {
+			auto &next_exp_cast = next_exp.Cast<BoundOperatorExpression>();
+			auto &child = *next_exp_cast.children[0];
 
 			// Test for equality on both 'a' and 'b' expressions
 			if (Expression::Equals(child, a_exp)) {
@@ -69,37 +68,35 @@ static unique_ptr<Expression> TryRewriteEqualOrIsNull(const Expression *equal_ex
 			} else if (Expression::Equals(child, b_exp)) {
 				b_is_null_found = true;
 			} else {
-				valid = false;
-				break;
+				return nullptr;
 			}
 		} else {
-			valid = false;
-			break;
+			return nullptr;
 		}
 	}
-	if (valid && a_is_null_found && b_is_null_found) {
+	if (a_is_null_found && b_is_null_found) {
 		return make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
-		                                            std::move(equal_cast->left), std::move(equal_cast->right));
+		                                            std::move(equal_cast.left), std::move(equal_cast.right));
 	}
 	return nullptr;
 }
 
-unique_ptr<Expression> EqualOrNullSimplification::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> EqualOrNullSimplification::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                         bool &changes_made, bool is_root) {
-	const Expression *or_exp = bindings[0];
+	const Expression &or_exp = bindings[0].get();
 
-	if (or_exp->type != ExpressionType::CONJUNCTION_OR) {
+	if (or_exp.type != ExpressionType::CONJUNCTION_OR) {
 		return nullptr;
 	}
 
-	const auto or_exp_cast = (BoundConjunctionExpression *)or_exp;
+	const auto &or_exp_cast = or_exp.Cast<BoundConjunctionExpression>();
 
-	if (or_exp_cast->children.size() != 2) {
+	if (or_exp_cast.children.size() != 2) {
 		return nullptr;
 	}
 
-	const auto left_exp = or_exp_cast->children[0].get();
-	const auto right_exp = or_exp_cast->children[1].get();
+	auto &left_exp = *or_exp_cast.children[0];
+	auto &right_exp = *or_exp_cast.children[1];
 	// Test for: a=b OR (a IS NULL AND b IS NULL)
 	auto first_try = TryRewriteEqualOrIsNull(left_exp, right_exp);
 	if (first_try) {

package/src/duckdb/src/optimizer/rule/in_clause_simplification_rule.cpp

@@ -12,10 +12,9 @@ InClauseSimplificationRule::InClauseSimplificationRule(ExpressionRewriter &rewri
 	root = std::move(op);
 }
 
-unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                          bool &changes_made, bool is_root) {
-	D_ASSERT(bindings[0]->expression_class == ExpressionClass::BOUND_OPERATOR);
-	auto &expr = bindings[0]->Cast<BoundOperatorExpression>();
+	auto &expr = bindings[0].get().Cast<BoundOperatorExpression>();
 	if (expr.children[0]->expression_class != ExpressionClass::BOUND_CAST) {
 		return nullptr;
 	}

package/src/duckdb/src/optimizer/rule/like_optimizations.cpp

@@ -99,10 +99,10 @@ static bool PatternIsContains(const string &pattern) {
 	return true;
 }
 
-unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                    bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[2]->Cast<BoundConstantExpression>();
+	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[2].get().Cast<BoundConstantExpression>();
 	D_ASSERT(root.children.size() == 2);
 
 	if (constant_expr.value.IsNull()) {

package/src/duckdb/src/optimizer/rule/move_constants.cpp

@@ -28,12 +28,12 @@ MoveConstantsRule::MoveConstantsRule(ExpressionRewriter &rewriter) : Rule(rewrit
 	root = std::move(op);
 }
 
-unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-                                                bool is_root) {
-	auto &comparison = bindings[0]->Cast<BoundComparisonExpression>();
-	auto &outer_constant = bindings[1]->Cast<BoundConstantExpression>();
-	auto &arithmetic = bindings[2]->Cast<BoundFunctionExpression>();
-	auto &inner_constant = bindings[3]->Cast<BoundConstantExpression>();
+unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
+                                                bool &changes_made, bool is_root) {
+	auto &comparison = bindings[0].get().Cast<BoundComparisonExpression>();
+	auto &outer_constant = bindings[1].get().Cast<BoundConstantExpression>();
+	auto &arithmetic = bindings[2].get().Cast<BoundFunctionExpression>();
+	auto &inner_constant = bindings[3].get().Cast<BoundConstantExpression>();
 	if (!TypeIsIntegral(arithmetic.return_type.InternalType())) {
 		return nullptr;
 	}

package/src/duckdb/src/optimizer/rule/ordered_aggregate_optimizer.cpp

@@ -11,9 +11,9 @@ OrderedAggregateOptimizer::OrderedAggregateOptimizer(ExpressionRewriter &rewrite
 	root->expr_class = ExpressionClass::BOUND_AGGREGATE;
 }
 
-unique_ptr<Expression> OrderedAggregateOptimizer::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> OrderedAggregateOptimizer::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                         bool &changes_made, bool is_root) {
-	auto &aggr = bindings[0]->Cast<BoundAggregateExpression>();
+	auto &aggr = bindings[0].get().Cast<BoundAggregateExpression>();
 	if (!aggr.order_bys) {
 		// no ORDER BYs defined
 		return nullptr;

package/src/duckdb/src/optimizer/rule/regex_optimizations.cpp

@@ -18,10 +18,10 @@ RegexOptimizationRule::RegexOptimizationRule(ExpressionRewriter &rewriter) : Rul
 	root = std::move(func);
 }
 
-unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                     bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
-	auto &constant_expr = bindings[2]->Cast<BoundConstantExpression>();
+	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[2].get().Cast<BoundConstantExpression>();
 	D_ASSERT(root.children.size() == 2);
 
 	if (constant_expr.value.IsNull()) {

package/src/duckdb/src/parser/expression_util.cpp

@@ -18,7 +18,7 @@ bool ExpressionUtil::ExpressionListEquals(const vector<unique_ptr<T>> &a, const
 	return true;
 }
 
-template <class T>
+template <class T, class EXPRESSION_MAP>
 bool ExpressionUtil::ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b) {
 	if (a.size() != b.size()) {
 		return false;
@@ -26,14 +26,14 @@ bool ExpressionUtil::ExpressionSetEquals(const vector<unique_ptr<T>> &a, const v
 	// we create a map of expression -> count for the left side
 	// we keep the count because the same expression can occur multiple times (e.g. "1 AND 1" is legal)
 	// in this case we track the following value: map["Constant(1)"] = 2
-	expression_map_t<idx_t> map;
+	EXPRESSION_MAP map;
 	for (idx_t i = 0; i < a.size(); i++) {
-		map[a[i].get()]++;
+		map[*a[i]]++;
 	}
 	// now on the right side we reduce the counts again
 	// if the conjunctions are identical, all the counts will be 0 after the
 	for (auto &expr : b) {
-		auto entry = map.find(expr.get());
+		auto entry = map.find(*expr);
 		// first we check if we can find the expression in the map at all
 		if (entry == map.end()) {
 			return false;
@@ -62,11 +62,11 @@ bool ExpressionUtil::ListEquals(const vector<unique_ptr<Expression>> &a, const v
 
 bool ExpressionUtil::SetEquals(const vector<unique_ptr<ParsedExpression>> &a,
                                const vector<unique_ptr<ParsedExpression>> &b) {
-	return ExpressionSetEquals<ParsedExpression>(a, b);
+	return ExpressionSetEquals<ParsedExpression, parsed_expression_map_t<idx_t>>(a, b);
 }
 
 bool ExpressionUtil::SetEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b) {
-	return ExpressionSetEquals<Expression>(a, b);
+	return ExpressionSetEquals<Expression, expression_map_t<idx_t>>(a, b);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parser.cpp

@@ -125,7 +125,7 @@ end:
 }
 
 void Parser::ParseQuery(const string &query) {
-	Transformer transformer(options.max_expression_depth);
+	Transformer transformer(options);
 	string parser_error;
 	{
 		// check if there are any unicode spaces in the string

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

@@ -10,6 +10,7 @@
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
+#include "duckdb/parser/parser_options.hpp"
 #include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
@@ -24,12 +25,15 @@ unique_ptr<ParsedExpression> Transformer::TransformUnaryOperator(const string &o
 	return std::move(result);
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &op, unique_ptr<ParsedExpression> left,
+unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(string op, unique_ptr<ParsedExpression> left,
                                                                   unique_ptr<ParsedExpression> right) {
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(std::move(left));
 	children.push_back(std::move(right));
 
+	if (options.integer_division && op == "/") {
+		op = "//";
+	}
 	if (op == "~" || op == "!~") {
 		// rewrite 'asdf' SIMILAR TO '.*sd.*' into regexp_full_match('asdf', '.*sd.*')
 		bool invert_similar = op == "!~";
@@ -47,7 +51,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &
 			return make_uniq<ComparisonExpression>(target_type, std::move(children[0]), std::move(children[1]));
 		}
 		// not a special operator: convert to a function expression
-		auto result = make_uniq<FunctionExpression>(op, std::move(children));
+		auto result = make_uniq<FunctionExpression>(std::move(op), std::move(children));
 		result->is_operator = true;
 		return std::move(result);
 	}
@@ -197,7 +201,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		// postfix operator, only ! is currently supported
 		return TransformUnaryOperator(name + "__postfix", std::move(left_expr));
 	} else {
-		return TransformBinaryOperator(name, std::move(left_expr), std::move(right_expr));
+		return TransformBinaryOperator(std::move(name), std::move(left_expr), std::move(right_expr));
 	}
 }
 

package/src/duckdb/src/parser/transform/helpers/transform_groupby.cpp

@@ -22,7 +22,7 @@ static void CheckGroupingSetCubes(idx_t current_count, idx_t cube_count) {
 }
 
 struct GroupingExpressionMap {
-	expression_map_t<idx_t> map;
+	parsed_expression_map_t<idx_t> map;
 };
 
 static GroupingSet VectorToGroupingSet(vector<idx_t> &indexes) {
@@ -49,11 +49,11 @@ void Transformer::AddGroupByExpression(unique_ptr<ParsedExpression> expression,
 			return;
 		}
 	}
-	auto entry = map.map.find(expression.get());
+	auto entry = map.map.find(*expression);
 	idx_t result_idx;
 	if (entry == map.map.end()) {
 		result_idx = result.group_expressions.size();
-		map.map[expression.get()] = result_idx;
+		map.map[*expression] = result_idx;
 		result.group_expressions.push_back(std::move(expression));
 	} else {
 		result_idx = entry->second;

package/src/duckdb/src/parser/transformer.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/parser_options.hpp"
 
 namespace duckdb {
 
@@ -21,12 +22,12 @@ StackChecker::StackChecker(StackChecker &&other) noexcept
 	other.stack_usage = 0;
 }
 
-Transformer::Transformer(idx_t max_expression_depth_p)
-    : parent(nullptr), max_expression_depth(max_expression_depth_p), stack_depth(DConstants::INVALID_INDEX) {
+Transformer::Transformer(ParserOptions &options)
+    : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
 }
 
 Transformer::Transformer(Transformer *parent)
-    : parent(parent), max_expression_depth(parent->max_expression_depth), stack_depth(DConstants::INVALID_INDEX) {
+    : parent(parent), options(parent->options), stack_depth(DConstants::INVALID_INDEX) {
 }
 
 Transformer::~Transformer() {
@@ -63,10 +64,10 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 		node = node->parent;
 	}
 	D_ASSERT(node->stack_depth != DConstants::INVALID_INDEX);
-	if (node->stack_depth + extra_stack >= max_expression_depth) {
+	if (node->stack_depth + extra_stack >= options.max_expression_depth) {
 		throw ParserException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
 		                      "increase the maximum expression depth.",
-		                      max_expression_depth);
+		                      options.max_expression_depth);
 	}
 	return StackChecker(*node, extra_stack);
 }

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

@@ -233,11 +233,11 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 
 	// check for all the aggregates if this aggregate already exists
 	idx_t aggr_index;
-	auto entry = node.aggregate_map.find(aggregate.get());
+	auto entry = node.aggregate_map.find(*aggregate);
 	if (entry == node.aggregate_map.end()) {
 		// new aggregate: insert into aggregate list
 		aggr_index = node.aggregates.size();
-		node.aggregate_map.insert(make_pair(aggregate.get(), aggr_index));
+		node.aggregate_map[*aggregate] = aggr_index;
 		node.aggregates.push_back(std::move(aggregate));
 	} else {
 		// duplicate aggregate: simplify refer to this aggregate

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

@@ -329,7 +329,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 
 	// create a mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
 	case_insensitive_map_t<idx_t> alias_map;
-	expression_map_t<idx_t> projection_map;
+	parsed_expression_map_t<idx_t> projection_map;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		auto &expr = statement.select_list[i];
 		result->names.push_back(expr->GetName());
@@ -338,7 +338,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			alias_map[expr->alias] = i;
 			result->names[i] = expr->alias;
 		}
-		projection_map[expr.get()] = i;
+		projection_map[*expr] = i;
 		result->original_expressions.push_back(expr->Copy());
 	}
 	result->column_count = statement.select_list.size();
@@ -391,7 +391,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			// hence we convert "a" -> "test.a" in the unbound expression
 			unbound_groups[i] = std::move(group_binder.unbound_expression);
 			ExpressionBinder::QualifyColumnNames(*this, unbound_groups[i]);
-			info.map[unbound_groups[i].get()] = i;
+			info.map[*unbound_groups[i]] = i;
 		}
 	}
 	result->groups.grouping_sets = std::move(statement.groups.grouping_sets);