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