feat(query): support ASOF JOIN USING

KKould · KKould · commit 80cdd45439f3 · 2026-05-19T12:29:29.000+08:00
diff --git a/src/query/sql/src/planner/binder/bind_table_reference/bind_join.rs b/src/query/sql/src/planner/binder/bind_table_reference/bind_join.rs
@@ -46,6 +46,7 @@ use crate::planner::semantic::NameResolutionContext;
 use crate::plans::BoundColumnRef;
 use crate::plans::EvalScalar;
 use crate::plans::Filter;
+use crate::plans::FunctionCall;
 use crate::plans::HashJoinBuildCacheInfo;
 use crate::plans::Join;
 use crate::plans::JoinEquiCondition;
@@ -61,6 +62,8 @@ pub struct JoinConditions {
     pub(crate) other_conditions: Vec<ScalarExpr>,
 }
 
+const ASOF_USING_RANGE_FUNC: &str = "gte";
+
 impl Binder {
     pub(crate) fn bind_join(
         &mut self,
@@ -732,6 +735,7 @@ impl<'a> JoinConditionResolver<'a> {
                     using_columns,
                     left_join_conditions,
                     right_join_conditions,
+                    non_equi_conditions,
                     join_op,
                 )?;
             }
@@ -746,6 +750,7 @@ impl<'a> JoinConditionResolver<'a> {
                     using_columns,
                     left_join_conditions,
                     right_join_conditions,
+                    non_equi_conditions,
                     join_op,
                 )?
             }
@@ -907,6 +912,7 @@ impl<'a> JoinConditionResolver<'a> {
         using_columns: Vec<(Span, String)>,
         left_join_conditions: &mut Vec<ScalarExpr>,
         right_join_conditions: &mut Vec<ScalarExpr>,
+        non_equi_conditions: &mut Vec<ScalarExpr>,
         join_op: &JoinOperator,
     ) -> Result<()> {
         bind_join_columns(
@@ -915,7 +921,18 @@ impl<'a> JoinConditionResolver<'a> {
             self.join_context,
         );
         let left_columns_len = self.left_column_bindings.len();
-        for (span, join_key) in using_columns.iter() {
+        let asof_range_column = if matches!(
+            join_op,
+            JoinOperator::Asof
+                | JoinOperator::LeftAsof
+                | JoinOperator::RightAsof
+                | JoinOperator::FullAsof
+        ) {
+            using_columns.len().checked_sub(1)
+        } else {
+            None
+        };
+        for (index, (span, join_key)) in using_columns.iter().enumerate() {
             let join_key_name = join_key.as_str();
             let left_scalar = if let Some(col_binding) = self.join_context.columns
                 [0..left_columns_len]
@@ -950,7 +967,8 @@ impl<'a> JoinConditionResolver<'a> {
                 ))
                 .set_span(*span));
             };
-            let idx = !matches!(join_op, JoinOperator::RightOuter) as usize;
+            let idx =
+                !matches!(join_op, JoinOperator::RightOuter | JoinOperator::RightAsof) as usize;
             if let Some(col_binding) = self
                 .join_context
                 .columns
@@ -961,16 +979,25 @@ impl<'a> JoinConditionResolver<'a> {
                 })
                 .nth(idx)
             {
-                // Always make the second using column in the join_context invisible in unqualified wildcard.
+                // Make the duplicate USING column invisible in unqualified wildcard.
                 col_binding.visibility = Visibility::UnqualifiedWildcardInVisible;
             }
 
-            self.add_equi_conditions(
-                left_scalar,
-                right_scalar,
-                left_join_conditions,
-                right_join_conditions,
-            )?;
+            if Some(index) == asof_range_column {
+                non_equi_conditions.push(ScalarExpr::FunctionCall(FunctionCall {
+                    span: *span,
+                    func_name: ASOF_USING_RANGE_FUNC.to_string(),
+                    params: vec![],
+                    arguments: vec![left_scalar, right_scalar],
+                }));
+            } else {
+                self.add_equi_conditions(
+                    left_scalar,
+                    right_scalar,
+                    left_join_conditions,
+                    right_join_conditions,
+                )?;
+            }
         }
         Ok(())
     }
diff --git a/tests/sqllogictests/suites/duckdb/join/asof/test_asof_join_eq_hash_fast_path.test b/tests/sqllogictests/suites/duckdb/join/asof/test_asof_join_eq_hash_fast_path.test
@@ -52,6 +52,20 @@ order by t.id
 3 20
 4 11
 
+# ASOF USING treats the final USING column as the range key and the
+# preceding USING columns as equality keys.
+query I?II
+select *
+from asof_eq_trades t
+asof join asof_eq_prices p
+    using (symbol, wh)
+order by id
+----
+1 2020-01-01 00:00:01.000000 1 10
+2 2020-01-01 00:00:03.000000 2 20
+3 2020-01-01 00:00:05.000000 2 20
+4 2020-01-01 00:00:06.000000 1 11
+
 # Left ASOF should preserve unmatched rows as NULL while keeping the same
 # nearest-predecessor semantics for matched rows.
 query II
@@ -68,6 +82,20 @@ order by t.id
 5 NULL
 6 NULL
 
+query II
+select t.id, p.price
+from asof_eq_trades t
+asof left join asof_eq_prices p
+    using (symbol, wh)
+order by t.id
+----
+1 10
+2 20
+3 20
+4 11
+5 NULL
+6 NULL
+
 # Right ASOF should preserve unmatched build-side rows from the original
 # `prices` table after the ASOF rewrite swaps the physical children.
 query II
@@ -100,6 +128,34 @@ order by t.id, p.price
 6 NULL
 NULL 21
 
+query II
+select p.price, t.id
+from asof_eq_trades t
+asof right join asof_eq_prices p
+    using (symbol, wh)
+order by p.price, t.id
+----
+10 1
+11 4
+20 2
+20 3
+21 NULL
+
+query II
+select t.id, p.price
+from asof_eq_trades t
+asof full join asof_eq_prices p
+    using (symbol, wh)
+order by t.id, p.price
+----
+1 10
+2 20
+3 20
+4 11
+5 NULL
+6 NULL
+NULL 21
+
 statement ok
 drop table asof_eq_trades
 
