duckdb 0.3.1-dev306.0 → 0.3.1-dev332.0

package/src/duckdb.cpp

@@ -1028,10 +1028,12 @@ public:
 	static void ResolveParameterType(LogicalType &type);
 	static void ResolveParameterType(unique_ptr<Expression> &expr);
 
-protected:
+	//! Bind the given expresion. Unlike Bind(), this does *not* mute the given ParsedExpression.
+	//! Exposed to be used from sub-binders that aren't subclasses of ExpressionBinder.
 	virtual BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                                  bool root_expression = false);
 
+protected:
 	BindResult BindExpression(BetweenExpression &expr, idx_t depth);
 	BindResult BindExpression(CaseExpression &expr, idx_t depth);
 	BindResult BindExpression(CollateExpression &expr, idx_t depth);
@@ -1331,6 +1333,7 @@ public:
 
 namespace duckdb {
 class BoundResultModifier;
+class BoundSelectNode;
 class ClientContext;
 class ExpressionBinder;
 class LimitModifier;
@@ -1544,7 +1547,6 @@ private:
 
 	BoundStatement BindSummarize(ShowStatement &stmt);
 	unique_ptr<BoundResultModifier> BindLimit(LimitModifier &limit_mod);
-	unique_ptr<Expression> BindFilter(unique_ptr<ParsedExpression> condition);
 	unique_ptr<Expression> BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr);
 
 	unique_ptr<LogicalOperator> PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root);
@@ -24400,6 +24402,9 @@ static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict)
 						return false;
 					}
 					pos++;
+					if (pos >= len) {
+						return false;
+					}
 					int64_t exponent = 0;
 					int negative = buf[pos] == '-';
 					if (negative) {
@@ -58187,10 +58192,8 @@ SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, Cl
 		D_ASSERT(sink.hash_table->equality_types.size() == 1);
 		auto key_type = sink.hash_table->equality_types[0];
 		use_perfect_hash = sink.perfect_join_executor->BuildPerfectHashTable(key_type);
-	} else {
-		sink.perfect_join_executor.reset();
 	}
-	// In case large build side or duplicates, use regular hash join
+	// In case of a large build side or duplicates, use regular hash join
 	if (!use_perfect_hash) {
 		sink.perfect_join_executor.reset();
 		sink.hash_table->Finalize();
@@ -66462,7 +66465,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 			return;
 		}
 	}
-	// with integral types
+	// with integral internal types
 	for (auto &&join_stat : op.join_stats) {
 		if (!TypeIsInteger(join_stat->type.InternalType()) || join_stat->type.InternalType() == PhysicalType::INT128) {
 			// perfect join not possible for non-integral types or hugeint
@@ -66487,7 +66490,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	join_state.build_min = stats_build->min;
 	join_state.build_max = stats_build->max;
 	join_state.estimated_cardinality = op.estimated_cardinality;
-	if (build_range.type().id() == LogicalTypeId::DECIMAL) {
+	if (!build_range.type().IsIntegral()) {
 		switch (build_range.type().InternalType()) {
 		case PhysicalType::INT16:
 			join_state.build_range = build_range.value_.smallint;
@@ -66499,19 +66502,15 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 			join_state.build_range = build_range.value_.bigint;
 			break;
 		case PhysicalType::INT128:
-			throw InternalException("PhysicalType::INT128 not yet implemented for Perfect HJ");
-			//			join_state.build_range = build_range.GetValue<idx_t>();
-			//			break;
+			// we do not support hugeint for this optimization
+			return;
 		default:
 			throw InternalException("Invalid Physical Type for Decimals");
 		}
 	} else {
 		join_state.build_range = build_range.GetValue<idx_t>(); // cast integer types into idx_t
 	}
-	if (join_state.build_range > MAX_BUILD_SIZE) {
-		return;
-	}
-	if (stats_probe->max.is_null || stats_probe->min.is_null) {
+	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.is_null || stats_probe->min.is_null) {
 		return;
 	}
 	if (stats_build->min <= stats_probe->min && stats_probe->max <= stats_build->max) {
@@ -127199,45 +127198,44 @@ private:
 	// Expression Transform
 	//===--------------------------------------------------------------------===//
 	//! Transform a Postgres boolean expression into an Expression
-	unique_ptr<ParsedExpression> TransformBoolExpr(duckdb_libpgquery::PGBoolExpr *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformBoolExpr(duckdb_libpgquery::PGBoolExpr *root);
 	//! Transform a Postgres case expression into an Expression
-	unique_ptr<ParsedExpression> TransformCase(duckdb_libpgquery::PGCaseExpr *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformCase(duckdb_libpgquery::PGCaseExpr *root);
 	//! Transform a Postgres type cast into an Expression
-	unique_ptr<ParsedExpression> TransformTypeCast(duckdb_libpgquery::PGTypeCast *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformTypeCast(duckdb_libpgquery::PGTypeCast *root);
 	//! Transform a Postgres coalesce into an Expression
-	unique_ptr<ParsedExpression> TransformCoalesce(duckdb_libpgquery::PGAExpr *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformCoalesce(duckdb_libpgquery::PGAExpr *root);
 	//! Transform a Postgres column reference into an Expression
-	unique_ptr<ParsedExpression> TransformColumnRef(duckdb_libpgquery::PGColumnRef *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformColumnRef(duckdb_libpgquery::PGColumnRef *root);
 	//! Transform a Postgres constant value into an Expression
-	unique_ptr<ConstantExpression> TransformValue(duckdb_libpgquery::PGValue val, idx_t depth);
+	unique_ptr<ConstantExpression> TransformValue(duckdb_libpgquery::PGValue val);
 	//! Transform a Postgres operator into an Expression
-	unique_ptr<ParsedExpression> TransformAExpr(duckdb_libpgquery::PGAExpr *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformAExpr(duckdb_libpgquery::PGAExpr *root);
 	//! Transform a Postgres abstract expression into an Expression
-	unique_ptr<ParsedExpression> TransformExpression(duckdb_libpgquery::PGNode *node, idx_t depth);
+	unique_ptr<ParsedExpression> TransformExpression(duckdb_libpgquery::PGNode *node);
 	//! Transform a Postgres function call into an Expression
-	unique_ptr<ParsedExpression> TransformFuncCall(duckdb_libpgquery::PGFuncCall *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformFuncCall(duckdb_libpgquery::PGFuncCall *root);
 	//! Transform a Postgres boolean expression into an Expression
-	unique_ptr<ParsedExpression> TransformInterval(duckdb_libpgquery::PGIntervalConstant *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformInterval(duckdb_libpgquery::PGIntervalConstant *root);
 	//! Transform a Postgres lambda node [e.g. (x, y) -> x + y] into a lambda expression
-	unique_ptr<ParsedExpression> TransformLambda(duckdb_libpgquery::PGLambdaFunction *node, idx_t depth);
+	unique_ptr<ParsedExpression> TransformLambda(duckdb_libpgquery::PGLambdaFunction *node);
 	//! Transform a Postgres array access node (e.g. x[1] or x[1:3])
-	unique_ptr<ParsedExpression> TransformArrayAccess(duckdb_libpgquery::PGAIndirection *node, idx_t depth);
+	unique_ptr<ParsedExpression> TransformArrayAccess(duckdb_libpgquery::PGAIndirection *node);
 	//! Transform a positional reference (e.g. #1)
-	unique_ptr<ParsedExpression> TransformPositionalReference(duckdb_libpgquery::PGPositionalReference *node,
-	                                                          idx_t depth);
-	unique_ptr<ParsedExpression> TransformStarExpression(duckdb_libpgquery::PGNode *node, idx_t depth);
+	unique_ptr<ParsedExpression> TransformPositionalReference(duckdb_libpgquery::PGPositionalReference *node);
+	unique_ptr<ParsedExpression> TransformStarExpression(duckdb_libpgquery::PGNode *node);
 
 	//! Transform a Postgres constant value into an Expression
-	unique_ptr<ParsedExpression> TransformConstant(duckdb_libpgquery::PGAConst *c, idx_t depth);
-	unique_ptr<ParsedExpression> TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc *n, idx_t depth);
-	unique_ptr<ParsedExpression> TransformResTarget(duckdb_libpgquery::PGResTarget *root, idx_t depth);
-	unique_ptr<ParsedExpression> TransformNullTest(duckdb_libpgquery::PGNullTest *root, idx_t depth);
-	unique_ptr<ParsedExpression> TransformParamRef(duckdb_libpgquery::PGParamRef *node, idx_t depth);
-	unique_ptr<ParsedExpression> TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformConstant(duckdb_libpgquery::PGAConst *c);
+	unique_ptr<ParsedExpression> TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc *n);
+	unique_ptr<ParsedExpression> TransformResTarget(duckdb_libpgquery::PGResTarget *root);
+	unique_ptr<ParsedExpression> TransformNullTest(duckdb_libpgquery::PGNullTest *root);
+	unique_ptr<ParsedExpression> TransformParamRef(duckdb_libpgquery::PGParamRef *node);
+	unique_ptr<ParsedExpression> TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr *root);
 
-	unique_ptr<ParsedExpression> TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction *node, idx_t depth);
+	unique_ptr<ParsedExpression> TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction *node);
 
-	unique_ptr<ParsedExpression> TransformSubquery(duckdb_libpgquery::PGSubLink *root, idx_t depth);
+	unique_ptr<ParsedExpression> TransformSubquery(duckdb_libpgquery::PGSubLink *root);
 	//===--------------------------------------------------------------------===//
 	// Constraints transform
 	//===--------------------------------------------------------------------===//
@@ -127249,7 +127247,7 @@ private:
 	//===--------------------------------------------------------------------===//
 	// Collation transform
 	//===--------------------------------------------------------------------===//
-	unique_ptr<ParsedExpression> TransformCollateExpr(duckdb_libpgquery::PGCollateClause *collate, idx_t depth);
+	unique_ptr<ParsedExpression> TransformCollateExpr(duckdb_libpgquery::PGCollateClause *collate);
 
 	string TransformCollation(duckdb_libpgquery::PGCollateClause *collate);
 
@@ -127304,15 +127302,24 @@ private:
 	bool TransformOrderBy(duckdb_libpgquery::PGList *order, vector<OrderByNode> &result);
 
 	//! Transform a Postgres SELECT clause into a list of Expressions
-	void TransformExpressionList(duckdb_libpgquery::PGList &list, vector<unique_ptr<ParsedExpression>> &result,
-	                             idx_t depth);
+	void TransformExpressionList(duckdb_libpgquery::PGList &list, vector<unique_ptr<ParsedExpression>> &result);
 
 	//! Transform a Postgres PARTITION BY/ORDER BY specification into lists of expressions
-	void TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr, idx_t depth);
+	void TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr);
 	//! Transform a Postgres window frame specification into frame expressions
-	void TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr, idx_t depth);
+	void TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr);
 
 	unique_ptr<SampleOptions> TransformSampleOptions(duckdb_libpgquery::PGNode *options);
+
+private:
+	//! Default stack limit of the transformer
+	constexpr static idx_t MAX_STACK_SIZE = 1024 * 100;
+	//! For iterative functions that create recursive objects, this is our default stack size per element
+	constexpr static idx_t DEFAULT_ENTRY_STACK_SIZE = 100;
+	int *root = nullptr;
+
+	void InitializeStackCheck(int *stack_check_var);
+	void StackCheck(idx_t extra_stack = 0);
 };
 
 } // namespace duckdb
@@ -129340,11 +129347,11 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		return make_unique<UniqueConstraint>(columns, is_primary_key);
 	}
 	case duckdb_libpgquery::PG_CONSTR_CHECK: {
-		auto expression = TransformExpression(constraint->raw_expr, 0);
+		auto expression = TransformExpression(constraint->raw_expr);
 		if (expression->HasSubquery()) {
 			throw ParserException("subqueries prohibited in CHECK constraints");
 		}
-		return make_unique<CheckConstraint>(TransformExpression(constraint->raw_expr, 0));
+		return make_unique<CheckConstraint>(TransformExpression(constraint->raw_expr));
 	}
 	default:
 		throw NotImplementedException("Constraint type not handled yet!");
@@ -129367,7 +129374,7 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 	case duckdb_libpgquery::PG_CONSTR_NULL:
 		return nullptr;
 	case duckdb_libpgquery::PG_CONSTR_DEFAULT:
-		column.default_value = TransformExpression(constraint->raw_expr, 0);
+		column.default_value = TransformExpression(constraint->raw_expr);
 		return nullptr;
 	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
 	default:
@@ -129384,15 +129391,15 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery::PGAIndirection *indirection_node,
-                                                               idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery::PGAIndirection *indirection_node) {
 	// transform the source expression
 	unique_ptr<ParsedExpression> result;
-	result = TransformExpression(indirection_node->arg, depth + 1);
+	result = TransformExpression(indirection_node->arg);
 
 	// now go over the indices
 	// note that a single indirection node can contain multiple indices
 	// this happens for e.g. more complex accesses (e.g. (foo).field1[42])
+	idx_t list_size = 0;
 	for (auto node = indirection_node->indirection->head; node != nullptr; node = node->next) {
 		auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
 		D_ASSERT(target);
@@ -129406,15 +129413,15 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			if (index->is_slice) {
 				// slice
 				children.push_back(!index->lidx ? make_unique<ConstantExpression>(Value())
-				                                : TransformExpression(index->lidx, depth + 1));
+				                                : TransformExpression(index->lidx));
 				children.push_back(!index->uidx ? make_unique<ConstantExpression>(Value())
-				                                : TransformExpression(index->uidx, depth + 1));
+				                                : TransformExpression(index->uidx));
 				result = make_unique<OperatorExpression>(ExpressionType::ARRAY_SLICE, move(children));
 			} else {
 				// array access
 				D_ASSERT(!index->lidx);
 				D_ASSERT(index->uidx);
-				children.push_back(TransformExpression(index->uidx, depth + 1));
+				children.push_back(TransformExpression(index->uidx));
 				result = make_unique<OperatorExpression>(ExpressionType::ARRAY_EXTRACT, move(children));
 			}
 			break;
@@ -129423,13 +129430,15 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			auto val = (duckdb_libpgquery::PGValue *)target;
 			vector<unique_ptr<ParsedExpression>> children;
 			children.push_back(move(result));
-			children.push_back(TransformValue(*val, depth + 1));
+			children.push_back(TransformValue(*val));
 			result = make_unique<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, move(children));
 			break;
 		}
 		default:
 			throw NotImplementedException("Unimplemented subscript type");
 		}
+		list_size++;
+		StackCheck(list_size * DEFAULT_ENTRY_STACK_SIZE);
 	}
 	return result;
 }
@@ -129441,10 +129450,10 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::PGBoolExpr *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::PGBoolExpr *root) {
 	unique_ptr<ParsedExpression> result;
 	for (auto node = root->args->head; node != nullptr; node = node->next) {
-		auto next = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value), depth + 1);
+		auto next = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value));
 
 		switch (root->boolop) {
 		case duckdb_libpgquery::PG_AND_EXPR: {
@@ -129492,7 +129501,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::P
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCaseExpr *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCaseExpr *root) {
 	D_ASSERT(root);
 
 	auto case_node = make_unique<CaseExpression>();
@@ -129500,22 +129509,21 @@ unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCas
 		CaseCheck case_check;
 
 		auto w = reinterpret_cast<duckdb_libpgquery::PGCaseWhen *>(cell->data.ptr_value);
-		auto test_raw = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->expr), depth + 1);
+		auto test_raw = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->expr));
 		unique_ptr<ParsedExpression> test;
-		auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg), depth + 1);
+		auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
 		if (arg) {
 			case_check.when_expr =
 			    make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, move(arg), move(test_raw));
 		} else {
 			case_check.when_expr = move(test_raw);
 		}
-		case_check.then_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->result), depth + 1);
+		case_check.then_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->result));
 		case_node->case_checks.push_back(move(case_check));
 	}
 
 	if (root->defresult) {
-		case_node->else_expr =
-		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->defresult), depth + 1);
+		case_node->else_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->defresult));
 	} else {
 		case_node->else_expr = make_unique<ConstantExpression>(Value(LogicalType::SQLNULL));
 	}
@@ -129531,7 +129539,7 @@ unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCas
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformTypeCast(duckdb_libpgquery::PGTypeCast *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformTypeCast(duckdb_libpgquery::PGTypeCast *root) {
 	D_ASSERT(root);
 
 	// get the type to cast to
@@ -129546,7 +129554,7 @@ unique_ptr<ParsedExpression> Transformer::TransformTypeCast(duckdb_libpgquery::P
 		}
 	}
 	// transform the expression node
-	auto expression = TransformExpression(root->arg, depth + 1);
+	auto expression = TransformExpression(root->arg);
 	bool try_cast = root->tryCast;
 
 	// now create a cast operation
@@ -129561,7 +129569,7 @@ namespace duckdb {
 
 // COALESCE(a,b,c) returns the first argument that is NOT NULL, so
 // rewrite into CASE(a IS NOT NULL, a, CASE(b IS NOT NULL, b, c))
-unique_ptr<ParsedExpression> Transformer::TransformCoalesce(duckdb_libpgquery::PGAExpr *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformCoalesce(duckdb_libpgquery::PGAExpr *root) {
 	D_ASSERT(root);
 
 	auto coalesce_args = reinterpret_cast<duckdb_libpgquery::PGList *>(root->lexpr);
@@ -129570,8 +129578,7 @@ unique_ptr<ParsedExpression> Transformer::TransformCoalesce(duckdb_libpgquery::P
 	auto coalesce_op = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
 	for (auto cell = coalesce_args->head; cell; cell = cell->next) {
 		// get the value of the COALESCE
-		auto value_expr =
-		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value), depth + 1);
+		auto value_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value));
 		coalesce_op->children.push_back(move(value_expr));
 	}
 	return move(coalesce_op);
@@ -129585,7 +129592,7 @@ unique_ptr<ParsedExpression> Transformer::TransformCoalesce(duckdb_libpgquery::P
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgquery::PGNode *node, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgquery::PGNode *node) {
 	auto star = (duckdb_libpgquery::PGAStar *)node;
 	auto result = make_unique<StarExpression>(star->relation ? star->relation : string());
 	if (star->except_list) {
@@ -129603,8 +129610,7 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 		for (auto head = star->replace_list->head; head; head = head->next) {
 			auto list = (duckdb_libpgquery::PGList *)head->data.ptr_value;
 			D_ASSERT(list->length == 2);
-			auto replace_expression =
-			    TransformExpression((duckdb_libpgquery::PGNode *)list->head->data.ptr_value, depth + 1);
+			auto replace_expression = TransformExpression((duckdb_libpgquery::PGNode *)list->head->data.ptr_value);
 			auto value = (duckdb_libpgquery::PGValue *)list->tail->data.ptr_value;
 			D_ASSERT(value->type == duckdb_libpgquery::T_PGString);
 			string exclude_entry = value->val.str;
@@ -129620,7 +129626,7 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 	return move(result);
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::PGColumnRef *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::PGColumnRef *root) {
 	auto fields = root->fields;
 	auto head_node = (duckdb_libpgquery::PGNode *)fields->head->data.ptr_value;
 	switch (head_node->type) {
@@ -129652,7 +129658,7 @@ unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::
 		}
 	}
 	case duckdb_libpgquery::T_PGAStar: {
-		return TransformStarExpression(head_node, depth);
+		return TransformStarExpression(head_node);
 	}
 	default:
 		throw NotImplementedException("ColumnRef not implemented!");
@@ -129668,7 +129674,7 @@ unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::
 
 namespace duckdb {
 
-unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PGValue val, idx_t depth) {
+unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PGValue val) {
 	switch (val.type) {
 	case duckdb_libpgquery::T_PGInteger:
 		D_ASSERT(val.val.ival <= NumericLimits<int32_t>::Maximum());
@@ -129735,8 +129741,8 @@ unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PG
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::PGAConst *c, idx_t depth) {
-	return TransformValue(c->val, depth + 1);
+unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::PGAConst *c) {
+	return TransformValue(c->val);
 }
 
 } // namespace duckdb
@@ -129746,10 +129752,10 @@ unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::P
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformResTarget(duckdb_libpgquery::PGResTarget *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformResTarget(duckdb_libpgquery::PGResTarget *root) {
 	D_ASSERT(root);
 
-	auto expr = TransformExpression(root->val, depth + 1);
+	auto expr = TransformExpression(root->val);
 	if (!expr) {
 		return nullptr;
 	}
@@ -129759,80 +129765,78 @@ unique_ptr<ParsedExpression> Transformer::TransformResTarget(duckdb_libpgquery::
 	return expr;
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr *root) {
 	D_ASSERT(root);
 
-	auto expr = TransformExpression((duckdb_libpgquery::PGNode *)root->arg, depth + 1);
+	auto expr = TransformExpression((duckdb_libpgquery::PGNode *)root->arg);
 	if (root->name) {
 		expr->alias = string(root->name);
 	}
 	return expr;
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery::PGNode *node, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery::PGNode *node) {
 	if (!node) {
 		return nullptr;
 	}
 
-	if (depth > max_expression_depth) {
-		throw ParserException("Expression tree is too deep (maximum depth %d)", max_expression_depth);
-	}
+	StackCheck();
 
 	switch (node->type) {
 	case duckdb_libpgquery::T_PGColumnRef:
-		return TransformColumnRef(reinterpret_cast<duckdb_libpgquery::PGColumnRef *>(node), depth);
+		return TransformColumnRef(reinterpret_cast<duckdb_libpgquery::PGColumnRef *>(node));
 	case duckdb_libpgquery::T_PGAConst:
-		return TransformConstant(reinterpret_cast<duckdb_libpgquery::PGAConst *>(node), depth);
+		return TransformConstant(reinterpret_cast<duckdb_libpgquery::PGAConst *>(node));
 	case duckdb_libpgquery::T_PGAExpr:
-		return TransformAExpr(reinterpret_cast<duckdb_libpgquery::PGAExpr *>(node), depth);
+		return TransformAExpr(reinterpret_cast<duckdb_libpgquery::PGAExpr *>(node));
 	case duckdb_libpgquery::T_PGFuncCall:
-		return TransformFuncCall(reinterpret_cast<duckdb_libpgquery::PGFuncCall *>(node), depth);
+		return TransformFuncCall(reinterpret_cast<duckdb_libpgquery::PGFuncCall *>(node));
 	case duckdb_libpgquery::T_PGBoolExpr:
-		return TransformBoolExpr(reinterpret_cast<duckdb_libpgquery::PGBoolExpr *>(node), depth);
+		return TransformBoolExpr(reinterpret_cast<duckdb_libpgquery::PGBoolExpr *>(node));
 	case duckdb_libpgquery::T_PGTypeCast:
-		return TransformTypeCast(reinterpret_cast<duckdb_libpgquery::PGTypeCast *>(node), depth);
+		return TransformTypeCast(reinterpret_cast<duckdb_libpgquery::PGTypeCast *>(node));
 	case duckdb_libpgquery::T_PGCaseExpr:
-		return TransformCase(reinterpret_cast<duckdb_libpgquery::PGCaseExpr *>(node), depth);
+		return TransformCase(reinterpret_cast<duckdb_libpgquery::PGCaseExpr *>(node));
 	case duckdb_libpgquery::T_PGSubLink:
-		return TransformSubquery(reinterpret_cast<duckdb_libpgquery::PGSubLink *>(node), depth);
+		return TransformSubquery(reinterpret_cast<duckdb_libpgquery::PGSubLink *>(node));
 	case duckdb_libpgquery::T_PGCoalesceExpr:
-		return TransformCoalesce(reinterpret_cast<duckdb_libpgquery::PGAExpr *>(node), depth);
+		return TransformCoalesce(reinterpret_cast<duckdb_libpgquery::PGAExpr *>(node));
 	case duckdb_libpgquery::T_PGNullTest:
-		return TransformNullTest(reinterpret_cast<duckdb_libpgquery::PGNullTest *>(node), depth);
+		return TransformNullTest(reinterpret_cast<duckdb_libpgquery::PGNullTest *>(node));
 	case duckdb_libpgquery::T_PGResTarget:
-		return TransformResTarget(reinterpret_cast<duckdb_libpgquery::PGResTarget *>(node), depth);
+		return TransformResTarget(reinterpret_cast<duckdb_libpgquery::PGResTarget *>(node));
 	case duckdb_libpgquery::T_PGParamRef:
-		return TransformParamRef(reinterpret_cast<duckdb_libpgquery::PGParamRef *>(node), depth);
+		return TransformParamRef(reinterpret_cast<duckdb_libpgquery::PGParamRef *>(node));
 	case duckdb_libpgquery::T_PGNamedArgExpr:
-		return TransformNamedArg(reinterpret_cast<duckdb_libpgquery::PGNamedArgExpr *>(node), depth);
+		return TransformNamedArg(reinterpret_cast<duckdb_libpgquery::PGNamedArgExpr *>(node));
 	case duckdb_libpgquery::T_PGSQLValueFunction:
-		return TransformSQLValueFunction(reinterpret_cast<duckdb_libpgquery::PGSQLValueFunction *>(node), depth);
+		return TransformSQLValueFunction(reinterpret_cast<duckdb_libpgquery::PGSQLValueFunction *>(node));
 	case duckdb_libpgquery::T_PGSetToDefault:
 		return make_unique<DefaultExpression>();
 	case duckdb_libpgquery::T_PGCollateClause:
-		return TransformCollateExpr(reinterpret_cast<duckdb_libpgquery::PGCollateClause *>(node), depth);
+		return TransformCollateExpr(reinterpret_cast<duckdb_libpgquery::PGCollateClause *>(node));
 	case duckdb_libpgquery::T_PGIntervalConstant:
-		return TransformInterval(reinterpret_cast<duckdb_libpgquery::PGIntervalConstant *>(node), depth);
+		return TransformInterval(reinterpret_cast<duckdb_libpgquery::PGIntervalConstant *>(node));
 	case duckdb_libpgquery::T_PGLambdaFunction:
-		return TransformLambda(reinterpret_cast<duckdb_libpgquery::PGLambdaFunction *>(node), depth);
+		return TransformLambda(reinterpret_cast<duckdb_libpgquery::PGLambdaFunction *>(node));
 	case duckdb_libpgquery::T_PGAIndirection:
-		return TransformArrayAccess(reinterpret_cast<duckdb_libpgquery::PGAIndirection *>(node), depth);
+		return TransformArrayAccess(reinterpret_cast<duckdb_libpgquery::PGAIndirection *>(node));
 	case duckdb_libpgquery::T_PGPositionalReference:
-		return TransformPositionalReference(reinterpret_cast<duckdb_libpgquery::PGPositionalReference *>(node), depth);
+		return TransformPositionalReference(reinterpret_cast<duckdb_libpgquery::PGPositionalReference *>(node));
 	case duckdb_libpgquery::T_PGGroupingFunc:
-		return TransformGroupingFunction(reinterpret_cast<duckdb_libpgquery::PGGroupingFunc *>(node), depth);
+		return TransformGroupingFunction(reinterpret_cast<duckdb_libpgquery::PGGroupingFunc *>(node));
 	default:
 		throw NotImplementedException("Expr of type %d not implemented\n", (int)node->type);
 	}
 }
 
-void Transformer::TransformExpressionList(duckdb_libpgquery::PGList &list, vector<unique_ptr<ParsedExpression>> &result,
-                                          idx_t depth) {
+void Transformer::TransformExpressionList(duckdb_libpgquery::PGList &list,
+                                          vector<unique_ptr<ParsedExpression>> &result) {
 	for (auto node = list.head; node != nullptr; node = node->next) {
 		auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
 		D_ASSERT(target);
 
-		auto expr = TransformExpression(target, depth + 1);
+		auto expr = TransformExpression(target);
 		D_ASSERT(expr);
 
 		result.push_back(move(expr));
@@ -129881,25 +129885,24 @@ static ExpressionType WindowToExpressionType(string &fun_name) {
 	return ExpressionType::WINDOW_AGGREGATE;
 }
 
-void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr, idx_t depth) {
+void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
 	D_ASSERT(window_spec);
 	D_ASSERT(expr);
 
 	// next: partitioning/ordering expressions
 	if (window_spec->partitionClause) {
-		TransformExpressionList(*window_spec->partitionClause, expr->partitions, depth);
+		TransformExpressionList(*window_spec->partitionClause, expr->partitions);
 	}
 	TransformOrderBy(window_spec->orderClause, expr->orders);
 }
 
-void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr,
-                                       idx_t depth) {
+void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
 	D_ASSERT(window_spec);
 	D_ASSERT(expr);
 
 	// finally: specifics of bounds
-	expr->start_expr = TransformExpression(window_spec->startOffset, depth + 1);
-	expr->end_expr = TransformExpression(window_spec->endOffset, depth + 1);
+	expr->start_expr = TransformExpression(window_spec->startOffset);
+	expr->end_expr = TransformExpression(window_spec->endOffset);
 
 	if ((window_spec->frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING) ||
 	    (window_spec->frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)) {
@@ -129937,7 +129940,7 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_sp
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall *root) {
 	auto name = root->funcname;
 	string schema, function_name;
 	if (name->length == 2) {
@@ -129971,7 +129974,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 
 		if (root->args) {
 			vector<unique_ptr<ParsedExpression>> function_list;
-			TransformExpressionList(*root->args, function_list, depth);
+			TransformExpressionList(*root->args, function_list);
 
 			if (win_fun_type == ExpressionType::WINDOW_AGGREGATE) {
 				for (auto &child : function_list) {
@@ -130023,8 +130026,8 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			window_ref = it->second;
 			D_ASSERT(window_ref);
 		}
-		TransformWindowDef(window_ref, expr.get(), depth);
-		TransformWindowFrame(window_spec, expr.get(), depth);
+		TransformWindowDef(window_ref, expr.get());
+		TransformWindowFrame(window_spec, expr.get());
 		expr->query_location = root->location;
 		return move(expr);
 	}
@@ -130033,13 +130036,13 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 	vector<unique_ptr<ParsedExpression>> children;
 	if (root->args != nullptr) {
 		for (auto node = root->args->head; node != nullptr; node = node->next) {
-			auto child_expr = TransformExpression((duckdb_libpgquery::PGNode *)node->data.ptr_value, depth + 1);
+			auto child_expr = TransformExpression((duckdb_libpgquery::PGNode *)node->data.ptr_value);
 			children.push_back(move(child_expr));
 		}
 	}
 	unique_ptr<ParsedExpression> filter_expr;
 	if (root->agg_filter) {
-		filter_expr = TransformExpression(root->agg_filter, depth + 1);
+		filter_expr = TransformExpression(root->agg_filter);
 	}
 
 	auto order_bys = make_unique<OrderModifier>();
@@ -130148,8 +130151,7 @@ static string SQLValueOpToString(duckdb_libpgquery::PGSQLValueFunctionOp op) {
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction *node,
-                                                                    idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction *node) {
 	D_ASSERT(node);
 	vector<unique_ptr<ParsedExpression>> children;
 	auto fname = SQLValueOpToString(node->op);
@@ -130162,11 +130164,11 @@ unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpg
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc *n, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc *n) {
 	auto op = make_unique<OperatorExpression>(ExpressionType::GROUPING_FUNCTION);
 	for (auto node = n->args->head; node; node = node->next) {
 		auto n = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
-		op->children.push_back(TransformExpression(n, depth + 1));
+		op->children.push_back(TransformExpression(n));
 	}
 	op->query_location = n->location;
 	return move(op);
@@ -130181,7 +130183,7 @@ unique_ptr<ParsedExpression> Transformer::TransformGroupingFunction(duckdb_libpg
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::PGIntervalConstant *node, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::PGIntervalConstant *node) {
 	// handle post-fix notation of INTERVAL
 
 	// three scenarios
@@ -130191,7 +130193,7 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 	unique_ptr<ParsedExpression> expr;
 	switch (node->val_type) {
 	case duckdb_libpgquery::T_PGAExpr:
-		expr = TransformExpression(node->eval, depth + 1);
+		expr = TransformExpression(node->eval);
 		break;
 	case duckdb_libpgquery::T_PGString:
 		expr = make_unique<ConstantExpression>(Value(node->sval));
@@ -130298,9 +130300,9 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformNullTest(duckdb_libpgquery::PGNullTest *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformNullTest(duckdb_libpgquery::PGNullTest *root) {
 	D_ASSERT(root);
-	auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg), depth + 1);
+	auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
 	if (root->argisrow) {
 		throw NotImplementedException("IS NULL argisrow");
 	}
@@ -130330,16 +130332,16 @@ static string ExtractColumnFromLambda(ParsedExpression &expr) {
 	return colref.column_name;
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGLambdaFunction *node, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGLambdaFunction *node) {
 	vector<unique_ptr<ParsedExpression>> parameter_expressions;
-	TransformExpressionList(*node->parameters, parameter_expressions, depth + 1);
+	TransformExpressionList(*node->parameters, parameter_expressions);
 	vector<string> parameters;
 	parameters.reserve(parameter_expressions.size());
 	for (auto &expr : parameter_expressions) {
 		parameters.push_back(ExtractColumnFromLambda(*expr));
 	}
 
-	auto lambda_function = TransformExpression(node->function, depth + 1);
+	auto lambda_function = TransformExpression(node->function);
 	return make_unique<LambdaExpression>(move(parameters), move(lambda_function));
 }
 
@@ -130420,7 +130422,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr *root) {
 	D_ASSERT(root);
 	auto name = string((reinterpret_cast<duckdb_libpgquery::PGValue *>(root->name->head->data.ptr_value))->val.str);
 
@@ -130429,8 +130431,8 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 	case duckdb_libpgquery::PG_AEXPR_OP_ANY: {
 		// left=ANY(right)
 		// we turn this into left=ANY((SELECT UNNEST(right)))
-		auto left_expr = TransformExpression(root->lexpr, depth + 1);
-		auto right_expr = TransformExpression(root->rexpr, depth + 1);
+		auto left_expr = TransformExpression(root->lexpr);
+		auto right_expr = TransformExpression(root->rexpr);
 
 		auto subquery_expr = make_unique<SubqueryExpression>();
 		auto select_statement = make_unique<SelectStatement>();
@@ -130457,7 +130459,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 		return move(subquery_expr);
 	}
 	case duckdb_libpgquery::PG_AEXPR_IN: {
-		auto left_expr = TransformExpression(root->lexpr, depth + 1);
+		auto left_expr = TransformExpression(root->lexpr);
 		ExpressionType operator_type;
 		// this looks very odd, but seems to be the way to find out its NOT IN
 		if (name == "<>") {
@@ -130469,14 +130471,14 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 		}
 		auto result = make_unique<OperatorExpression>(operator_type, move(left_expr));
 		result->query_location = root->location;
-		TransformExpressionList(*((duckdb_libpgquery::PGList *)root->rexpr), result->children, depth);
+		TransformExpressionList(*((duckdb_libpgquery::PGList *)root->rexpr), result->children);
 		return move(result);
 	}
 	// rewrite NULLIF(a, b) into CASE WHEN a=b THEN NULL ELSE a END
 	case duckdb_libpgquery::PG_AEXPR_NULLIF: {
 		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(TransformExpression(root->lexpr, depth + 1));
-		children.push_back(TransformExpression(root->rexpr, depth + 1));
+		children.push_back(TransformExpression(root->lexpr));
+		children.push_back(TransformExpression(root->rexpr));
 		return make_unique<FunctionExpression>("nullif", move(children));
 	}
 	// rewrite (NOT) X BETWEEN A AND B into (NOT) AND(GREATERTHANOREQUALTO(X,
@@ -130488,11 +130490,11 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 			throw InternalException("(NOT) BETWEEN needs two args");
 		}
 
-		auto input = TransformExpression(root->lexpr, depth + 1);
-		auto between_left = TransformExpression(
-		    reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->head->data.ptr_value), depth + 1);
-		auto between_right = TransformExpression(
-		    reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->tail->data.ptr_value), depth + 1);
+		auto input = TransformExpression(root->lexpr);
+		auto between_left =
+		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->head->data.ptr_value));
+		auto between_right =
+		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->tail->data.ptr_value));
 
 		auto compare_between = make_unique<BetweenExpression>(move(input), move(between_left), move(between_right));
 		if (root->kind == duckdb_libpgquery::PG_AEXPR_BETWEEN) {
@@ -130503,8 +130505,8 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 	}
 	// rewrite SIMILAR TO into regexp_full_match('asdf', '.*sd.*')
 	case duckdb_libpgquery::PG_AEXPR_SIMILAR: {
-		auto left_expr = TransformExpression(root->lexpr, depth + 1);
-		auto right_expr = TransformExpression(root->rexpr, depth + 1);
+		auto left_expr = TransformExpression(root->lexpr);
+		auto right_expr = TransformExpression(root->rexpr);
 
 		vector<unique_ptr<ParsedExpression>> children;
 		children.push_back(move(left_expr));
@@ -130539,14 +130541,14 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 		}
 	}
 	case duckdb_libpgquery::PG_AEXPR_NOT_DISTINCT: {
-		auto left_expr = TransformExpression(root->lexpr, depth + 1);
-		auto right_expr = TransformExpression(root->rexpr, depth + 1);
+		auto left_expr = TransformExpression(root->lexpr);
+		auto right_expr = TransformExpression(root->rexpr);
 		return make_unique<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM, move(left_expr),
 		                                         move(right_expr));
 	}
 	case duckdb_libpgquery::PG_AEXPR_DISTINCT: {
-		auto left_expr = TransformExpression(root->lexpr, depth + 1);
-		auto right_expr = TransformExpression(root->rexpr, depth + 1);
+		auto left_expr = TransformExpression(root->lexpr);
+		auto right_expr = TransformExpression(root->rexpr);
 		return make_unique<ComparisonExpression>(ExpressionType::COMPARE_DISTINCT_FROM, move(left_expr),
 		                                         move(right_expr));
 	}
@@ -130554,8 +130556,8 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 	default:
 		break;
 	}
-	auto left_expr = TransformExpression(root->lexpr, depth + 1);
-	auto right_expr = TransformExpression(root->rexpr, depth + 1);
+	auto left_expr = TransformExpression(root->lexpr);
+	auto right_expr = TransformExpression(root->rexpr);
 
 	if (!left_expr) {
 		// prefix operator
@@ -130575,7 +130577,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef *node, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef *node) {
 	D_ASSERT(node);
 	auto expr = make_unique<ParameterExpression>();
 	if (node->number == 0) {
@@ -130594,8 +130596,7 @@ unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::P
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_libpgquery::PGPositionalReference *node,
-                                                                       idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_libpgquery::PGPositionalReference *node) {
 	if (node->position <= 0) {
 		throw ParserException("Positional reference node needs to be >= 1");
 	}
@@ -130611,7 +130612,7 @@ unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_li
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink *root, idx_t depth) {
+unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink *root) {
 	D_ASSERT(root);
 	auto subquery_expr = make_unique<SubqueryExpression>();
 
@@ -130628,7 +130629,7 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 	case duckdb_libpgquery::PG_ALL_SUBLINK: {
 		// comparison with ANY() or ALL()
 		subquery_expr->subquery_type = SubqueryType::ANY;
-		subquery_expr->child = TransformExpression(root->testexpr, depth + 1);
+		subquery_expr->child = TransformExpression(root->testexpr);
 		// get the operator name
 		if (!root->operName) {
 			// simple IN
@@ -131665,7 +131666,7 @@ static void AddCubeSets(const GroupingSet &current_set, vector<GroupingSet> &res
 
 void Transformer::TransformGroupByExpression(duckdb_libpgquery::PGNode *n, GroupingExpressionMap &map,
                                              GroupByNode &result, vector<idx_t> &indexes) {
-	auto expression = TransformExpression(n, 0);
+	auto expression = TransformExpression(n);
 	AddGroupByExpression(move(expression), map, result, indexes);
 }
 
@@ -131797,7 +131798,7 @@ bool Transformer::TransformOrderBy(duckdb_libpgquery::PGList *order, vector<Orde
 			} else {
 				throw NotImplementedException("Unimplemented order by type");
 			}
-			auto order_expression = TransformExpression(target, 0);
+			auto order_expression = TransformExpression(target);
 			result.emplace_back(type, null_order, move(order_expression));
 		} else {
 			throw NotImplementedException("ORDER BY list member type %d\n", temp->type);
@@ -131834,7 +131835,7 @@ unique_ptr<SampleOptions> Transformer::TransformSampleOptions(duckdb_libpgquery:
 	auto result = make_unique<SampleOptions>();
 	auto &sample_options = (duckdb_libpgquery::PGSampleOptions &)*options;
 	auto &sample_size = (duckdb_libpgquery::PGSampleSize &)*sample_options.sample_size;
-	auto sample_value = TransformValue(sample_size.sample_size, 0)->value;
+	auto sample_value = TransformValue(sample_size.sample_size)->value;
 	result->is_percentage = sample_size.is_percentage;
 	if (sample_size.is_percentage) {
 		// sample size is given in sample_size: use system sampling
@@ -131871,6 +131872,9 @@ unique_ptr<SampleOptions> Transformer::TransformSampleOptions(duckdb_libpgquery:
 namespace duckdb {
 
 LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_name) {
+	if (type_name->type != duckdb_libpgquery::T_PGTypeName) {
+		throw ParserException("Expected a type");
+	}
 	auto name = (reinterpret_cast<duckdb_libpgquery::PGValue *>(type_name->names->tail->data.ptr_value)->val.str);
 	// transform it to the SQL type
 	LogicalTypeId base_type = TransformStringToLogicalType(name);
@@ -131885,7 +131889,9 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 
 		for (auto node = type_name->typmods->head; node; node = node->next) {
 			auto &type_val = *((duckdb_libpgquery::PGList *)node->data.ptr_value);
-			D_ASSERT(type_val.length == 2);
+			if (type_val.length != 2) {
+				throw ParserException("Struct entry needs an entry name and a type name");
+			}
 
 			auto entry_name_node = (duckdb_libpgquery::PGValue *)(type_val.head->data.ptr_value);
 			D_ASSERT(entry_name_node->type == duckdb_libpgquery::T_PGString);
@@ -132046,7 +132052,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_ColumnDefault: {
-			auto expr = TransformExpression(command->def, 0);
+			auto expr = TransformExpression(command->def);
 			result->info = make_unique<SetDefaultInfo>(qname.schema, qname.name, command->name, move(expr));
 			break;
 		}
@@ -132056,7 +132062,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 
 			unique_ptr<ParsedExpression> expr;
 			if (cdef->raw_default) {
-				expr = TransformExpression(cdef->raw_default, 0);
+				expr = TransformExpression(cdef->raw_default);
 			} else {
 				auto colref = make_unique<ColumnRefExpression>(command->name);
 				expr = make_unique<CastExpression>(column_definition.type, move(colref));
@@ -132086,7 +132092,7 @@ unique_ptr<CallStatement> Transformer::TransformCall(duckdb_libpgquery::PGNode *
 	D_ASSERT(stmt);
 
 	auto result = make_unique<CallStatement>();
-	result->function = TransformFuncCall((duckdb_libpgquery::PGFuncCall *)stmt->func, 0);
+	result->function = TransformFuncCall((duckdb_libpgquery::PGFuncCall *)stmt->func);
 	return result;
 }
 
@@ -132160,7 +132166,7 @@ void Transformer::TransformCopyOptions(CopyInfo &info, duckdb_libpgquery::PGList
 			break;
 		default:
 			info.options[def_elem->defname].push_back(
-			    TransformValue(*((duckdb_libpgquery::PGValue *)def_elem->arg), 0)->value);
+			    TransformValue(*((duckdb_libpgquery::PGValue *)def_elem->arg))->value);
 			break;
 		}
 	}
@@ -132255,13 +132261,13 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 	info->schema = qname.schema;
 	info->name = qname.name;
 
-	auto function = TransformExpression(stmt->function, 0);
+	auto function = TransformExpression(stmt->function);
 	D_ASSERT(function);
 	auto macro_func = make_unique<MacroFunction>(move(function));
 
 	if (stmt->params) {
 		vector<unique_ptr<ParsedExpression>> parameters;
-		TransformExpressionList(*stmt->params, parameters, 0);
+		TransformExpressionList(*stmt->params, parameters);
 		for (auto &param : parameters) {
 			if (param->type == ExpressionType::VALUE_CONSTANT) {
 				// parameters with default value (must have an alias)
@@ -132335,7 +132341,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery:
 		} else {
 			// parse the index expression
 			D_ASSERT(index_element->expr);
-			info->expressions.push_back(TransformExpression(index_element->expr, 0));
+			info->expressions.push_back(TransformExpression(index_element->expr));
 		}
 	}
 
@@ -132517,9 +132523,8 @@ OnCreateConflict Transformer::TransformOnConflict(duckdb_libpgquery::PGOnCreateC
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformCollateExpr(duckdb_libpgquery::PGCollateClause *collate,
-                                                               idx_t depth) {
-	auto child = TransformExpression(collate->arg, depth + 1);
+unique_ptr<ParsedExpression> Transformer::TransformCollateExpr(duckdb_libpgquery::PGCollateClause *collate) {
+	auto child = TransformExpression(collate->arg);
 	auto collation = TransformCollation(collate);
 	return make_unique<CollateExpression>(collation, move(child));
 }
@@ -132699,7 +132704,7 @@ unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGNo
 	D_ASSERT(stmt);
 	auto result = make_unique<DeleteStatement>();
 
-	result->condition = TransformExpression(stmt->whereClause, 0);
+	result->condition = TransformExpression(stmt->whereClause);
 	result->table = TransformRangeVar(stmt->relation);
 	if (result->table->type != TableReferenceType::BASE_TABLE) {
 		throw Exception("Can only delete from base tables!");
@@ -132837,7 +132842,7 @@ unique_ptr<TableRef> Transformer::TransformValuesList(duckdb_libpgquery::PGList
 		auto target = (duckdb_libpgquery::PGList *)(value_list->data.ptr_value);
 
 		vector<unique_ptr<ParsedExpression>> insert_values;
-		TransformExpressionList(*target, insert_values, 0);
+		TransformExpressionList(*target, insert_values);
 		if (!result->values.empty()) {
 			if (result->values[0].size() != insert_values.size()) {
 				throw ParserException("VALUES lists must all be the same length");
@@ -132910,13 +132915,13 @@ unique_ptr<PragmaStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNo
 	if (stmt->args) {
 		for (auto cell = stmt->args->head; cell != nullptr; cell = cell->next) {
 			auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value);
-			auto expr = TransformExpression(node, 0);
+			auto expr = TransformExpression(node);
 
 			if (expr->type == ExpressionType::COMPARE_EQUAL) {
 				auto &comp = (ComparisonExpression &)*expr;
 				info.named_parameters[comp.left->ToString()] = Value(comp.right->ToString());
 			} else if (node->type == duckdb_libpgquery::T_PGAConst) {
-				auto constant = TransformConstant((duckdb_libpgquery::PGAConst *)node, 0);
+				auto constant = TransformConstant((duckdb_libpgquery::PGAConst *)node);
 				info.parameters.push_back(((ConstantExpression &)*constant).value);
 			} else {
 				info.parameters.emplace_back(expr->ToString());
@@ -132979,7 +132984,7 @@ unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PG
 	result->name = string(stmt->name);
 
 	if (stmt->params) {
-		TransformExpressionList(*stmt->params, result->values, 0);
+		TransformExpressionList(*stmt->params, result->values);
 	}
 	for (auto &expr : result->values) {
 		if (!expr->IsScalar()) {
@@ -132992,6 +132997,9 @@ unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PG
 unique_ptr<DropStatement> Transformer::TransformDeallocate(duckdb_libpgquery::PGNode *node) {
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDeallocateStmt *>(node);
 	D_ASSERT(stmt);
+	if (!stmt->name) {
+		throw ParserException("DEALLOCATE requires a name");
+	}
 
 	auto result = make_unique<DropStatement>();
 	result->info->type = CatalogType::PREPARED_STATEMENT;
@@ -133144,7 +133152,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSele
 			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(stmt->distinctClause->head->data.ptr_value);
 			if (target) {
 				//  add the columns defined in the ON clause to the select list
-				TransformExpressionList(*stmt->distinctClause, modifier->distinct_on_targets, 0);
+				TransformExpressionList(*stmt->distinctClause, modifier->distinct_on_targets);
 			}
 			result->modifiers.push_back(move(modifier));
 		}
@@ -133160,16 +133168,16 @@ unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSele
 				throw ParserException("SELECT clause without selection list");
 			}
 			// select list
-			TransformExpressionList(*stmt->targetList, result->select_list, 0);
+			TransformExpressionList(*stmt->targetList, result->select_list);
 			result->from_table = TransformFrom(stmt->fromClause);
 		}
 
 		// where
-		result->where_clause = TransformExpression(stmt->whereClause, 0);
+		result->where_clause = TransformExpression(stmt->whereClause);
 		// group by
 		TransformGroupBy(stmt->groupClause, result->groups);
 		// having
-		result->having = TransformExpression(stmt->havingClause, 0);
+		result->having = TransformExpression(stmt->havingClause);
 		// sample
 		result->sample = TransformSampleOptions(stmt->sampleOptions);
 		break;
@@ -133226,10 +133234,10 @@ unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSele
 	if (stmt->limitCount || stmt->limitOffset) {
 		auto limit_modifier = make_unique<LimitModifier>();
 		if (stmt->limitCount) {
-			limit_modifier->limit = TransformExpression(stmt->limitCount, 0);
+			limit_modifier->limit = TransformExpression(stmt->limitCount);
 		}
 		if (stmt->limitOffset) {
-			limit_modifier->offset = TransformExpression(stmt->limitOffset, 0);
+			limit_modifier->offset = TransformExpression(stmt->limitOffset);
 		}
 		node->modifiers.push_back(move(limit_modifier));
 	}
@@ -133283,7 +133291,7 @@ unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGNode *no
 	D_ASSERT(stmt->args->head && stmt->args->head->data.ptr_value);
 	D_ASSERT(((duckdb_libpgquery::PGNode *)stmt->args->head->data.ptr_value)->type == duckdb_libpgquery::T_PGAConst);
 
-	auto value = TransformValue(((duckdb_libpgquery::PGAConst *)stmt->args->head->data.ptr_value)->val, 0)->value;
+	auto value = TransformValue(((duckdb_libpgquery::PGAConst *)stmt->args->head->data.ptr_value)->val)->value;
 
 	return make_unique<SetStatement>(name, value, ToSetScope(stmt->scope));
 }
@@ -133396,10 +133404,10 @@ unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNo
 	for (auto cell = root->head; cell != nullptr; cell = cell->next) {
 		auto target = (duckdb_libpgquery::PGResTarget *)(cell->data.ptr_value);
 		result->columns.emplace_back(target->name);
-		result->expressions.push_back(TransformExpression(target->val, 0));
+		result->expressions.push_back(TransformExpression(target->val));
 	}
 
-	result->condition = TransformExpression(stmt->whereClause, 0);
+	result->condition = TransformExpression(stmt->whereClause);
 	return result;
 }
 
@@ -133471,6 +133479,7 @@ unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root)
 		// Cross Product
 		auto result = make_unique<CrossProductRef>();
 		CrossProductRef *cur_root = result.get();
+		idx_t list_size = 0;
 		for (auto node = root->head; node != nullptr; node = node->next) {
 			auto n = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
 			unique_ptr<TableRef> next = TransformTableRefNode(n);
@@ -133485,6 +133494,8 @@ unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root)
 				result->right = move(next);
 				cur_root = result.get();
 			}
+			list_size++;
+			StackCheck(list_size * DEFAULT_ENTRY_STACK_SIZE);
 		}
 		return move(result);
 	}
@@ -133553,7 +133564,7 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *r
 		cross->right = move(result->right);
 		return move(cross);
 	}
-	result->condition = TransformExpression(root->quals, 0);
+	result->condition = TransformExpression(root->quals);
 	return move(result);
 }
 
@@ -133610,12 +133621,12 @@ unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRa
 	switch (call_tree->type) {
 	case duckdb_libpgquery::T_PGFuncCall: {
 		auto func_call = (duckdb_libpgquery::PGFuncCall *)call_tree;
-		result->function = TransformFuncCall(func_call, 0);
+		result->function = TransformFuncCall(func_call);
 		result->query_location = func_call->location;
 		break;
 	}
 	case duckdb_libpgquery::T_PGSQLValueFunction:
-		result->function = TransformSQLValueFunction((duckdb_libpgquery::PGSQLValueFunction *)call_tree, 0);
+		result->function = TransformSQLValueFunction((duckdb_libpgquery::PGSQLValueFunction *)call_tree);
 		break;
 	default:
 		throw ParserException("Not a function call or value function");
@@ -133635,6 +133646,8 @@ unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRa
 namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNode *n) {
+	StackCheck();
+
 	switch (n->type) {
 	case duckdb_libpgquery::T_PGRangeVar:
 		return TransformRangeVar(reinterpret_cast<duckdb_libpgquery::PGRangeVar *>(n));
@@ -133679,6 +133692,8 @@ unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNod
 namespace duckdb {
 
 bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements) {
+	int stack_check_var;
+	InitializeStackCheck(&stack_check_var);
 	for (auto entry = tree->head; entry != nullptr; entry = entry->next) {
 		SetParamCount(0);
 		auto stmt = TransformStatement((duckdb_libpgquery::PGNode *)entry->data.ptr_value);
@@ -133689,6 +133704,26 @@ bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<uni
 	return true;
 }
 
+void Transformer::InitializeStackCheck(int *stack_check_var) {
+	this->root = stack_check_var;
+}
+
+void Transformer::StackCheck(idx_t extra_stack) {
+	if (!root) {
+		return;
+	}
+	int current_stack_var;
+	if (&current_stack_var > root) {
+		throw InternalException("Transformer::StackCheck variables are incorrectly set up");
+	}
+	idx_t stack_size = root - &current_stack_var + extra_stack;
+	if (stack_size > MAX_STACK_SIZE) {
+		throw ParserException(
+		    "Stack usage in parsing is too high: the query tree is too deep (stack usage %lld, max stack usage %lld)",
+		    stack_size, MAX_STACK_SIZE);
+	}
+}
+
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode *stmt) {
 	switch (stmt->type) {
 	case duckdb_libpgquery::T_PGRawStmt: {
@@ -135988,6 +136023,40 @@ unique_ptr<BoundQueryNode> Binder::BindNode(RecursiveCTENode &statement) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/column_alias_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class BoundSelectNode;
+class ColumnRefExpression;
+
+//! A helper binder for WhereBinder and HavingBinder which support alias as a columnref.
+class ColumnAliasBinder {
+public:
+	ColumnAliasBinder(BoundSelectNode &node, const unordered_map<string, idx_t> &alias_map);
+
+	BindResult BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
+	                     bool root_expression);
+
+private:
+	BoundSelectNode &node;
+	const unordered_map<string, idx_t> &alias_map;
+	bool in_alias;
+};
+
+} // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -136078,6 +136147,7 @@ protected:
 
 
 
+
 namespace duckdb {
 
 //! The HAVING binder is responsible for binding an expression within the HAVING clause of a SQL statement
@@ -136086,12 +136156,14 @@ public:
 	HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
 	             unordered_map<string, idx_t> &alias_map);
 
-	unordered_map<string, idx_t> &alias_map;
-	bool in_alias;
-
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
+
+private:
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+
+	ColumnAliasBinder column_alias_binder;
 };
 
 } // namespace duckdb
@@ -136154,16 +136226,23 @@ private:
 
 namespace duckdb {
 
+class ColumnAliasBinder;
+
 //! The WHERE binder is responsible for binding an expression within the WHERE clause of a SQL statement
 class WhereBinder : public ExpressionBinder {
 public:
-	WhereBinder(Binder &binder, ClientContext &context);
+	WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder = nullptr);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
+
+private:
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+
+	ColumnAliasBinder *column_alias_binder;
 };
 
 } // namespace duckdb
@@ -136172,10 +136251,6 @@ protected:
 
 
 namespace duckdb {
-unique_ptr<Expression> Binder::BindFilter(unique_ptr<ParsedExpression> condition) {
-	WhereBinder where_binder(*this, context);
-	return where_binder.Bind(condition);
-}
 
 unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr) {
 	// we treat the Distinct list as a order by
@@ -136374,7 +136449,10 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	// first visit the WHERE clause
 	// the WHERE clause happens before the GROUP BY, PROJECTION or HAVING clauses
 	if (statement.where_clause) {
-		result->where_clause = BindFilter(move(statement.where_clause));
+		ColumnAliasBinder alias_binder(*result, alias_map);
+		WhereBinder where_binder(*this, context, &alias_binder);
+		unique_ptr<ParsedExpression> condition = move(statement.where_clause);
+		result->where_clause = where_binder.Bind(condition);
 	}
 
 	// now bind all the result modifiers; including DISTINCT and ORDER BY targets
@@ -141718,6 +141796,38 @@ BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
 } // namespace duckdb
 
 
+
+
+
+
+namespace duckdb {
+
+ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const unordered_map<string, idx_t> &alias_map)
+    : node(node), alias_map(alias_map), in_alias(false) {
+}
+
+BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
+                                        bool root_expression) {
+	if (!expr.table_name.empty()) {
+		return BindResult(StringUtil::Format("Alias %s cannot be qualified.", expr.ToString()));
+	}
+
+	auto alias_entry = alias_map.find(expr.column_name);
+	if (alias_entry == alias_map.end()) {
+		return BindResult(StringUtil::Format("Alias %s is not found.", expr.ToString()));
+	}
+
+	// found an alias: bind the alias expression
+	D_ASSERT(!in_alias);
+	auto expression = node.original_expressions[alias_entry->second]->Copy();
+	in_alias = true;
+	auto result = enclosing_binder.BindExpression(&expression, depth, root_expression);
+	in_alias = false;
+	return result;
+}
+
+} // namespace duckdb
+
 namespace duckdb {
 
 ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string clause)
@@ -141865,10 +141975,21 @@ namespace duckdb {
 
 HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
                            unordered_map<string, idx_t> &alias_map)
-    : SelectBinder(binder, context, node, info), alias_map(alias_map), in_alias(false) {
+    : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
+BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = (ColumnRefExpression &)**expr_ptr;
+	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
+	if (!alias_result.HasError()) {
+		return alias_result;
+	}
+
+	return BindResult(StringUtil::Format(
+	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));
+}
+
 BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = **expr_ptr;
 	// check if the expression binds to one of the groups
@@ -141880,22 +142001,7 @@ BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr,
 	case ExpressionClass::WINDOW:
 		return BindResult("HAVING clause cannot contain window functions!");
 	case ExpressionClass::COLUMN_REF:
-		if (!in_alias) {
-			auto &colref = (ColumnRefExpression &)expr;
-			if (colref.table_name.empty()) {
-				auto alias_entry = alias_map.find(colref.column_name);
-				if (alias_entry != alias_map.end()) {
-					// found an alias: bind the alias expression
-					auto expression = node.original_expressions[alias_entry->second]->Copy();
-					in_alias = true;
-					auto result = BindExpression(&expression, depth, root_expression);
-					in_alias = false;
-					return result;
-				}
-			}
-		}
-		return BindResult(StringUtil::Format(
-		    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));
+		return BindColumnRef(expr_ptr, depth, root_expression);
 	default:
 		return duckdb::SelectBinder::BindExpression(expr_ptr, depth);
 	}
@@ -142229,12 +142335,30 @@ string UpdateBinder::UnsupportedAggregateMessage() {
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
-WhereBinder::WhereBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
+WhereBinder::WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder)
+    : ExpressionBinder(binder, context), column_alias_binder(column_alias_binder) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
+BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = (ColumnRefExpression &)**expr_ptr;
+	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
+	if (!result.HasError() || !column_alias_binder) {
+		return result;
+	}
+
+	BindResult alias_result = column_alias_binder->BindAlias(*this, expr, depth, root_expression);
+	// This code path cannot be exercised at thispoint. #1547 might change that.
+	if (!alias_result.HasError()) {
+		return alias_result;
+	}
+
+	return result;
+}
+
 BindResult WhereBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = **expr_ptr;
 	switch (expr.GetExpressionClass()) {
@@ -142242,6 +142366,8 @@ BindResult WhereBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, i
 		return BindResult("WHERE clause cannot contain DEFAULT clause");
 	case ExpressionClass::WINDOW:
 		return BindResult("WHERE clause cannot contain window functions!");
+	case ExpressionClass::COLUMN_REF:
+		return BindColumnRef(expr_ptr, depth, root_expression);
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}
@@ -142503,8 +142629,6 @@ void ExpressionBinder::BindTableNames(Binder &binder, ParsedExpression &expr, un
 			if (binder.macro_binding != nullptr && binder.macro_binding->HasMatchingBinding(colref.column_name)) {
 				// macro parameters get priority
 				colref.table_name = binder.macro_binding->alias;
-			} else if (alias_map && alias_map->find(colref.column_name) != alias_map->end()) {
-				// alias: leave unqualified
 			} else {
 				colref.table_name = binder.bind_context.GetMatchingBinding(colref.column_name);
 			}