flink-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From fhueske <...@git.apache.org>
Subject [GitHub] flink pull request #3715: [FLINK-6232][Table&SQL]Support proctime inner equi...
Date Tue, 04 Jul 2017 14:29:25 GMT
Github user fhueske commented on a diff in the pull request:

    https://github.com/apache/flink/pull/3715#discussion_r125457882
  
    --- 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.")
           }
     
    -    val timeOffset =
    -      // only preceding offset need to store records
    -      if (tmpTimeOffset < 0)
    -        // determain the boudary value
    +    val (leftLiteral, rightLiteral) =
    +      reduceTimeExpression(
    +        timeCall.operands.get(0),
    +        timeCall.operands.get(1),
    +        rexBuilder,
    +        config)
    +    val tmpTimeOffset: Long =
    +      if (isLeftExprBelongLeftTable) rightLiteral - leftLiteral else leftLiteral - rightLiteral
    +
    +    val boundary =
    +      tmpTimeOffset.signum * (
             if (timeTerm.getKind == SqlKind.LESS_THAN || timeTerm.getKind == SqlKind.GREATER_THAN)
{
    -          -tmpTimeOffset - 1
    +          tmpTimeOffset.abs - 1
             } else {
    -          -tmpTimeOffset
    -        }
    -      else 0
    +          tmpTimeOffset.abs
    +        })
     
    -    (timeOffset, isLeftTableTimeOffset)
    +    (boundary, isLeftLowerBound)
       }
     
       /**
         * Calcute the time boundary. Replace the rowtime/proctime with zero literal.
    --- End diff --
    
    ```
    Calculates the time boundary by replacing the time attribute by a zero literal and reducing
the expression.
    ```


---
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 infrastructure@apache.org or file a JIRA ticket
with INFRA.
---

Mime
View raw message