duckdb 0.7.2-dev904.0 → 0.7.2-dev982.0

package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp

@@ -113,7 +113,7 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 	bool non_reorderable_operation = false;
 	if (op->type == LogicalOperatorType::LOGICAL_UNION || op->type == LogicalOperatorType::LOGICAL_EXCEPT ||
 	    op->type == LogicalOperatorType::LOGICAL_INTERSECT || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN ||
-	    op->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
+	    op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
 		// set operation, optimize separately in children
 		non_reorderable_operation = true;
 	}
@@ -184,6 +184,7 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 	}
 
 	switch (op->type) {
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
 		// inner join or cross product
@@ -866,7 +867,8 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 						result_operator->children[0] = std::move(comp_join);
 					}
 				} else {
-					D_ASSERT(node->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
+					D_ASSERT(node->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
+					         node->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
 					auto &comp_join = (LogicalComparisonJoin &)*node;
 					comp_join.conditions.push_back(std::move(cond));
 				}
@@ -908,7 +910,8 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::RewritePlan(unique_ptr<LogicalOp
 	auto op = plan.get();
 	auto parent = plan.get();
 	while (op->type != LogicalOperatorType::LOGICAL_CROSS_PRODUCT &&
-	       op->type != LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+	       op->type != LogicalOperatorType::LOGICAL_COMPARISON_JOIN &&
+	       op->type != LogicalOperatorType::LOGICAL_ASOF_JOIN) {
 		D_ASSERT(op->children.size() == 1);
 		parent = op;
 		op = op->children[0].get();
@@ -943,7 +946,8 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 	// filters in the process
 	expression_set_t filter_set;
 	for (auto &f_op : filter_operators) {
-		if (f_op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+		if (f_op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
+		    f_op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
 			auto &join = (LogicalComparisonJoin &)*f_op;
 			D_ASSERT(join.join_type == JoinType::INNER);
 			D_ASSERT(join.expressions.empty());

package/src/duckdb/src/optimizer/pullup/pullup_from_left.cpp

@@ -6,8 +6,8 @@ namespace duckdb {
 
 unique_ptr<LogicalOperator> FilterPullup::PullupFromLeft(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_EXCEPT ||
-	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
+	         op->type == LogicalOperatorType::LOGICAL_EXCEPT || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
 
 	FilterPullup left_pullup(true, can_add_column);
 	FilterPullup right_pullup(false, can_add_column);

package/src/duckdb/src/optimizer/pushdown/pushdown_cross_product.cpp

@@ -46,7 +46,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<Logi
 		                                             right_bindings, join_expressions, conditions,
 		                                             arbitrary_expressions);
 		// create the join from the join conditions
-		return LogicalComparisonJoin::CreateJoin(JoinType::INNER, std::move(op->children[0]),
+		return LogicalComparisonJoin::CreateJoin(JoinType::INNER, JoinRefType::REGULAR, std::move(op->children[0]),
 		                                         std::move(op->children[1]), std::move(conditions),
 		                                         std::move(arbitrary_expressions));
 	} else {

package/src/duckdb/src/optimizer/pushdown/pushdown_inner_join.cpp

@@ -24,6 +24,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<Logical
 			// filter statically evaluates to false, strip tree
 			return make_unique<LogicalEmptyResult>(std::move(op));
 		}
+	} else if (op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
+		// Don't mess with non-standard condition interpretations
+		return FinishPushdown(std::move(op));
 	} else {
 		// comparison join
 		D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);

package/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp

@@ -68,7 +68,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 	// for a comparison join we create a FilterCombiner that checks if we can push conditions on LHS join conditions
 	// into the RHS of the join
 	FilterCombiner filter_combiner(optimizer);
-	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+	const auto isComparison = (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
+	                           op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
+	if (isComparison) {
 		// add all comparison conditions
 		auto &comparison_join = (LogicalComparisonJoin &)*op;
 		for (auto &cond : comparison_join.conditions) {
@@ -82,7 +84,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 		if (side == JoinSide::LEFT) {
 			// bindings match left side
 			// we can push the filter into the left side
-			if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+			if (isComparison) {
 				// we MIGHT be able to push it down the RHS as well, but only if it is a comparison that matches the
 				// join predicates we use the FilterCombiner to figure this out add the expression to the FilterCombiner
 				filter_combiner.AddFilter(filters[i]->filter->Copy());

package/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp

@@ -13,7 +13,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 	auto &comp_join = (LogicalComparisonJoin &)*op;
 	D_ASSERT(join.join_type == JoinType::MARK);
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN || op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
 
 	right_bindings.insert(comp_join.mark_index);
 	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);

package/src/duckdb/src/optimizer/remove_unused_columns.cpp

@@ -71,6 +71,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		remove.VisitOperator(*op.children[0]);
 		return;
 	}
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		if (!everything_referenced) {

package/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp

@@ -195,6 +195,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin
 	switch (join.type) {
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 		PropagateStatistics((LogicalComparisonJoin &)join, node_ptr);
 		break;
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:

package/src/duckdb/src/optimizer/statistics_propagator.cpp

@@ -36,6 +36,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalOper
 	case LogicalOperatorType::LOGICAL_PROJECTION:
 		return PropagateStatistics((LogicalProjection &)node, node_ptr);
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -18,6 +18,10 @@ string JoinRef::ToString() const {
 		result += "NATURAL ";
 		result += JoinTypeToString(type) + " JOIN ";
 		break;
+	case JoinRefType::ASOF:
+		result += "ASOF ";
+		result += JoinTypeToString(type) + " JOIN ";
+		break;
 	case JoinRefType::CROSS:
 		result += ", ";
 		break;

package/src/duckdb/src/parser/transform/tableref/transform_join.cpp

@@ -44,8 +44,15 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *r
 	// Check the type of left arg and right arg before transform
 	result->left = TransformTableRefNode(root->larg);
 	result->right = TransformTableRefNode(root->rarg);
-	if (root->isNatural) {
+	switch (root->joinreftype) {
+	case duckdb_libpgquery::PG_JOIN_NATURAL:
 		result->ref_type = JoinRefType::NATURAL;
+		break;
+	case duckdb_libpgquery::PG_JOIN_ASOF:
+		result->ref_type = JoinRefType::ASOF;
+		break;
+	default:
+		break;
 	}
 	result->query_location = root->location;
 

package/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp

@@ -25,11 +25,11 @@ static unique_ptr<ParsedExpression> BindColumn(Binder &binder, ClientContext &co
 
 static unique_ptr<ParsedExpression> AddCondition(ClientContext &context, Binder &left_binder, Binder &right_binder,
                                                  const string &left_alias, const string &right_alias,
-                                                 const string &column_name) {
+                                                 const string &column_name, ExpressionType type) {
 	ExpressionBinder expr_binder(left_binder, context);
 	auto left = BindColumn(left_binder, context, left_alias, column_name);
 	auto right = BindColumn(right_binder, context, right_alias, column_name);
-	return make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(left), std::move(right));
+	return make_unique<ComparisonExpression>(type, std::move(left), std::move(right));
 }
 
 bool Binder::TryFindBinding(const string &using_column, const string &join_side, string &result) {
@@ -198,12 +198,14 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		break;
 	}
 	case JoinRefType::REGULAR:
+	case JoinRefType::ASOF:
 		if (!ref.using_columns.empty()) {
 			// USING columns
 			D_ASSERT(!result->condition);
 			extra_using_columns = ref.using_columns;
 		}
 		break;
+
 	case JoinRefType::CROSS:
 	case JoinRefType::POSITIONAL:
 		break;
@@ -241,8 +243,13 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			left_binding = RetrieveUsingBinding(left_binder, left_using_binding, using_column, "left", set.get());
 			right_binding = RetrieveUsingBinding(right_binder, right_using_binding, using_column, "right", set.get());
 
+			// Last column of ASOF JOIN ... USING is >=
+			const auto type = (ref.ref_type == JoinRefType::ASOF && i == extra_using_columns.size() - 1)
+			                      ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
+			                      : ExpressionType::COMPARE_EQUAL;
+
 			extra_conditions.push_back(
-			    AddCondition(context, left_binder, right_binder, left_binding, right_binding, using_column));
+			    AddCondition(context, left_binder, right_binder, left_binding, right_binding, using_column, type));
 
 			AddUsingBindings(*set, left_using_binding, left_binding);
 			AddUsingBindings(*set, right_using_binding, right_binding);

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_any_join.hpp"
+#include "duckdb/planner/operator/logical_asof_join.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_cross_product.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
@@ -104,12 +105,43 @@ void LogicalComparisonJoin::ExtractJoinConditions(JoinType type, unique_ptr<Logi
 	return ExtractJoinConditions(type, left_child, right_child, expressions, conditions, arbitrary_expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, unique_ptr<LogicalOperator> left_child,
+unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, JoinRefType reftype,
+                                                              unique_ptr<LogicalOperator> left_child,
                                                               unique_ptr<LogicalOperator> right_child,
                                                               vector<JoinCondition> conditions,
                                                               vector<unique_ptr<Expression>> arbitrary_expressions) {
+	// Validate the conditions
 	bool need_to_consider_arbitrary_expressions = true;
-	if (type == JoinType::INNER) {
+	switch (reftype) {
+	case JoinRefType::ASOF: {
+		need_to_consider_arbitrary_expressions = false;
+		auto asof_idx = conditions.size();
+		for (size_t c = 0; c < conditions.size(); ++c) {
+			auto &cond = conditions[c];
+			switch (cond.comparison) {
+			case ExpressionType::COMPARE_EQUAL:
+			case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+				break;
+			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+				if (asof_idx < conditions.size()) {
+					throw BinderException("Multiple ASOF JOIN inequalities");
+				}
+				asof_idx = c;
+				break;
+			default:
+				throw BinderException("Invalid ASOF JOIN comparison");
+			}
+		}
+		if (asof_idx == conditions.size()) {
+			throw BinderException("Missing ASOF JOIN inequality");
+		}
+		break;
+	}
+	default:
+		break;
+	}
+
+	if (type == JoinType::INNER && reftype == JoinRefType::REGULAR) {
 		// for inner joins we can push arbitrary expressions as a filter
 		// here we prefer to create a comparison join if possible
 		// that way we can use the much faster hash join to process the main join
@@ -144,7 +176,12 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, uni
 	} else {
 		// we successfully converted expressions into JoinConditions
 		// create a LogicalComparisonJoin
-		auto comp_join = make_unique<LogicalComparisonJoin>(type);
+		unique_ptr<LogicalComparisonJoin> comp_join;
+		if (reftype == JoinRefType::ASOF) {
+			comp_join = make_unique<LogicalAsOfJoin>(type);
+		} else {
+			comp_join = make_unique<LogicalComparisonJoin>(type);
+		}
 		comp_join->conditions = std::move(conditions);
 		comp_join->children.push_back(std::move(left_child));
 		comp_join->children.push_back(std::move(right_child));
@@ -179,15 +216,16 @@ static bool HasCorrelatedColumns(Expression &expression) {
 	return has_correlated_columns;
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, unique_ptr<LogicalOperator> left_child,
+unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, JoinRefType reftype,
+                                                              unique_ptr<LogicalOperator> left_child,
                                                               unique_ptr<LogicalOperator> right_child,
                                                               unique_ptr<Expression> condition) {
 	vector<JoinCondition> conditions;
 	vector<unique_ptr<Expression>> arbitrary_expressions;
 	LogicalComparisonJoin::ExtractJoinConditions(type, left_child, right_child, std::move(condition), conditions,
 	                                             arbitrary_expressions);
-	return LogicalComparisonJoin::CreateJoin(type, std::move(left_child), std::move(right_child), std::move(conditions),
-	                                         std::move(arbitrary_expressions));
+	return LogicalComparisonJoin::CreateJoin(type, reftype, std::move(left_child), std::move(right_child),
+	                                         std::move(conditions), std::move(arbitrary_expressions));
 }
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
@@ -201,7 +239,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		// we reduce expression depth of all columns in the "ref.correlated_columns" set by 1
 		LateralBinder::ReduceExpressionDepth(*right, ref.correlated_columns);
 	}
-	if (ref.type == JoinType::RIGHT && ClientConfig::GetConfig(context).enable_optimizer) {
+	if (ref.type == JoinType::RIGHT && ref.ref_type != JoinRefType::ASOF &&
+	    ClientConfig::GetConfig(context).enable_optimizer) {
 		// we turn any right outer joins into left outer joins for optimization purposes
 		// they are the same but with sides flipped, so treating them the same simplifies life
 		ref.type = JoinType::LEFT;
@@ -220,7 +259,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	default:
 		break;
 	}
-	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition))) {
+	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition)) &&
+	    ref.ref_type == JoinRefType::REGULAR) {
 		// inner join, generate a cross product + filter
 		// this will be later turned into a proper join by the join order optimizer
 		auto root = LogicalCrossProduct::Create(std::move(left), std::move(right));
@@ -235,8 +275,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	}
 
 	// now create the join operator from the join condition
-	auto result =
-	    LogicalComparisonJoin::CreateJoin(ref.type, std::move(left), std::move(right), std::move(ref.condition));
+	auto result = LogicalComparisonJoin::CreateJoin(ref.type, ref.ref_type, std::move(left), std::move(right),
+	                                                std::move(ref.condition));
 
 	LogicalOperator *join;
 	if (result->type == LogicalOperatorType::LOGICAL_FILTER) {
@@ -254,7 +294,9 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	}
 
 	// we visit the expressions depending on the type of join
-	if (join->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+	switch (join->type) {
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		// comparison join
 		// in this join we visit the expressions on the LHS with the LHS as root node
 		// and the expressions on the RHS with the RHS as root node
@@ -263,12 +305,18 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 			PlanSubqueries(&comp_join.conditions[i].left, &comp_join.children[0]);
 			PlanSubqueries(&comp_join.conditions[i].right, &comp_join.children[1]);
 		}
-	} else if (join->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
 		auto &any_join = (LogicalAnyJoin &)*join;
 		// for the any join we just visit the condition
 		if (any_join.condition->HasSubquery()) {
 			throw NotImplementedException("Cannot perform non-inner join on subquery!");
 		}
+		break;
+	}
+	default:
+		break;
 	}
 	return result;
 }

package/src/duckdb/src/planner/logical_operator.cpp

@@ -257,6 +257,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 		result = LogicalDelimJoin::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+		result = LogicalAsOfJoin::Deserialize(state, reader);
+		break;
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		result = LogicalComparisonJoin::Deserialize(state, reader);
 		break;

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -65,6 +65,7 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		}
 		break;
 	}
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {

package/src/duckdb/src/planner/operator/logical_asof_join.cpp

@@ -0,0 +1,8 @@
+#include "duckdb/planner/operator/logical_asof_join.hpp"
+
+namespace duckdb {
+
+LogicalAsOfJoin::LogicalAsOfJoin(JoinType type) : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_ASOF_JOIN) {
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp

@@ -262,6 +262,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		return std::move(join);
 	}
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		auto &join = (LogicalJoin &)*plan;
 		D_ASSERT(plan->children.size() == 2);
@@ -334,7 +335,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			auto right = make_unique<BoundColumnRefExpression>(
 			    correlated_columns[i].type, ColumnBinding(right_binding.table_index, right_binding.column_index + i));
 
-			if (join.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+			if (join.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
+			    join.type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
 				JoinCondition cond;
 				cond.left = std::move(left);
 				cond.right = std::move(right);

package/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp

@@ -681,6 +681,38 @@ typedef enum PGJoinType {
 	 */
 } PGJoinType;
 
+/*
+ * PGJoinRefType -
+ *    enums for the types of implied conditions
+ *
+ * PGJoinRefType specifies the semantics of interpreting the join conditions.
+ * These can be explicit (e.g., REGULAR) implied (e.g., NATURAL)
+ * or interpreted in a particular manner (e.g., ASOF)
+ *
+ * This is a generalisation of the old Postgres isNatural flag.
+ */
+typedef enum PGJoinRefType {
+	PG_JOIN_REGULAR, /* Join conditions are interpreted as is */
+	PG_JOIN_NATURAL, /* Join conditions are inferred from the column names */
+
+	/*
+	 * ASOF joins are joins with a single inequality predicate
+	 * and optional equality predicates.
+	 * The semantics are equivalent to the following window join:
+	 * 		times t
+	 * 	<jointype> JOIN (
+     *		SELECT *,
+     *			LEAD(begin, 1, 'infinity') OVER ([PARTITION BY key] ORDER BY begin) AS end)
+	 * 		FROM events) e
+	 *	ON t.ts >= e.begin AND t.ts < e.end [AND t.key = e.key]
+	 */
+	PG_JOIN_ASOF
+
+	/*
+	 * Positional join is a candidate to move here
+	 */
+} PGJoinRefType;
+
 /*
  * OUTER joins are those for which pushed-down quals must behave differently
  * from the join's own quals.  This is in fact everything except INNER and

package/src/duckdb/third_party/libpg_query/include/nodes/primnodes.hpp

@@ -1324,7 +1324,7 @@ typedef struct PGRangeTblRef {
 /*----------
  * PGJoinExpr - for SQL JOIN expressions
  *
- * isNatural, usingClause, and quals are interdependent.  The user can write
+ * joinreftype, usingClause, and quals are interdependent.  The user can write
  * only one of NATURAL, USING(), or ON() (this is enforced by the grammar).
  * If he writes NATURAL then parse analysis generates the equivalent USING()
  * list, and from that fills in "quals" with the right equality comparisons.
@@ -1347,7 +1347,7 @@ typedef struct PGRangeTblRef {
 typedef struct PGJoinExpr {
 	PGNodeTag type;
 	PGJoinType jointype; /* type of join */
-	bool isNatural;      /* Natural join? Will need to shape table */
+	PGJoinRefType joinreftype; /* Regular/Natural/AsOf join? Will need to shape table */
 	PGNode *larg;        /* left subtree */
 	PGNode *rarg;        /* right subtree */
 	PGList *usingClause; /* USING clause, if any (list of String) */
@@ -1398,4 +1398,4 @@ typedef struct PGOnConflictExpr {
 	PGList *exclRelTlist;    /* tlist of the EXCLUDED pseudo relation */
 } PGOnConflictExpr;
 
-}
+}