Github user fhueske commented on a diff in the pull request:

    https://github.com/apache/flink/pull/3715#discussion_r125457556
  
    --- Diff: 
flink-libraries/flink-table/src/main/scala/org/apache/flink/table/runtime/join/WindowJoinUtil.scala
 ---
    @@ -210,77 +187,71 @@ object JoinUtil {
               case _ => Seq()
             }
           case c: RexCall =>
    -        c.operands.map(analyzeSingleConditionTerm(_, leftFieldCount, 
inputType)).reduce(_++_)
    +        c.operands.map(extractTimeIndicatorAccesses(_, leftFieldCount, 
inputType)).reduce(_++_)
           case _ => Seq()
         }
       }
     
       /**
    -    * Extract time offset and determain which table the offset belong to
    +    * Extract time offset and determain it's the lower bound of left 
stream or the upper bound
    +    *
    +    * @return window boundary, is left lower bound
         */
       def extractTimeOffsetFromCondition(
           timeTerm: RexNode,
           isLeftExprBelongLeftTable: Boolean,
           rexBuilder: RexBuilder,
    -      config: TableConfig) = {
    +      config: TableConfig): (Long, Boolean) = {
     
         val timeCall: RexCall = timeTerm.asInstanceOf[RexCall]
    -    val leftLiteral =
    -      reduceTimeExpression(
    -        timeCall.operands.get(0),
    -        rexBuilder,
    -        config)
     
    -    val rightLiteral =
    -      reduceTimeExpression(
    -        timeCall.operands.get(1),
    -        rexBuilder,
    -        config)
    -
    -    val (tmpTimeOffset: Long, isLeftTableTimeOffset: Boolean) =
    +    val isLeftLowerBound: Boolean =
           timeTerm.getKind match {
    -        // e.g a.proctime > b.proctime - 5 sec, we need to store stream a.
    -        // the left expr(a) belong to left table, so the offset belong to 
left table
    +        // e.g a.proctime > b.proctime - 5 sec, then it's the lower bound 
of a and the value is -5
    +        // e.g b.proctime > a.proctime - 5 sec, then it's not the lower 
bound of a but upper bound
             case kind @ (SqlKind.GREATER_THAN | SqlKind.GREATER_THAN_OR_EQUAL) 
=>
    -          (rightLiteral - leftLiteral, isLeftExprBelongLeftTable)
    -        // e.g a.proctime < b.proctime + 5 sec, we need to store stream b.
    +          isLeftExprBelongLeftTable
    +        // e.g a.proctime < b.proctime + 5 sec, the the upper bound of a 
is 5
             case kind @ (SqlKind.LESS_THAN | SqlKind.LESS_THAN_OR_EQUAL) =>
    -          (leftLiteral - rightLiteral, !isLeftExprBelongLeftTable)
    -        case _ => 0
    +          !isLeftExprBelongLeftTable
    +        case _ =>
    +          throw new TableException("Unsupport time-condition.")
    --- End diff --
    
    Unsupport -> Unsupported


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---

Reply via email to