executor/join : use shallow copy for join.

executor/joiner.go

@@ -91,7 +91,7 @@ func newJoiner(ctx sessionctx.Context, joinType plan.JoinType,
  colTypes := make([]*types.FieldType, 0, len(lhsColTypes)+len(rhsColTypes))
  colTypes = append(colTypes, lhsColTypes...)
  colTypes = append(colTypes, rhsColTypes...)
- base.chk = chunk.NewChunkWithCapacity(colTypes, ctx.GetSessionVars().MaxChunkSize)
+ base.mutRow = chunk.MutRowFromTypes(colTypes)
  base.selected = make([]bool, 0, chunk.InitialCapacity)
  if joinType == plan.LeftOuterJoin || joinType == plan.RightOuterJoin {
  innerColTypes := lhsColTypes
@@ -124,7 +124,7 @@ type baseJoiner struct {
  conditions []expression.Expression
  defaultInner chunk.Row
  outerIsRight bool
- chk  *chunk.Chunk
+ mutRow chunk.MutRow
  selected []bool
  maxChunkSize int
 }
@@ -142,6 +142,16 @@ func (j *baseJoiner) makeJoinRowToChunk(chk *chunk.Chunk, lhs, rhs chunk.Row) {
  chk.AppendPartialRow(lhs.Len(), rhs)
 }
 
+// makeJoinRow combines inner, outer row into mutRow.
+// combines will uses shadow copy inner and outer row data to mutRow.
+func (j *baseJoiner) makeJoinRow(isRightJoin bool, inner, outer chunk.Row) {
+ if !isRightJoin {
+ inner, outer = outer, inner
+ }
+ j.mutRow.ShadowCopyPartialRow(0, inner)
+ j.mutRow.ShadowCopyPartialRow(inner.Len(), outer)
+}
+
 func (j *baseJoiner) filter(input, output *chunk.Chunk) (matched bool, err error) {
  j.selected, err = expression.VectorizedFilter(j.ctx, j.conditions, chunk.NewIterator4Chunk(input), j.selected)
  if err != nil {
@@ -173,14 +183,9 @@ func (j *semiJoiner) tryToMatch(outer chunk.Row, inners chunk.Iterator, chk *chu
  }
 
  for inner := inners.Current(); inner != inners.End(); inner = inners.Next() {
- j.chk.Reset()
- if j.outerIsRight {
- j.makeJoinRowToChunk(j.chk, inner, outer)
- } else {
- j.makeJoinRowToChunk(j.chk, outer, inner)
- }
+ j.makeJoinRow(j.outerIsRight, inner, outer)
 
- matched, err = expression.EvalBool(j.ctx, j.conditions, j.chk.GetRow(0))
+ matched, err = expression.EvalBool(j.ctx, j.conditions, j.mutRow.ToRow())
  if err != nil {
  return false, errors.Trace(err)
  }
@@ -212,14 +217,9 @@ func (j *antiSemiJoiner) tryToMatch(outer chunk.Row, inners chunk.Iterator, chk
  }
 
  for inner := inners.Current(); inner != inners.End(); inner = inners.Next() {
- j.chk.Reset()
- if j.outerIsRight {
- j.makeJoinRowToChunk(j.chk, inner, outer)
- } else {
- j.makeJoinRowToChunk(j.chk, outer, inner)
- }
+ j.makeJoinRow(j.outerIsRight, inner, outer)
 
- matched, err = expression.EvalBool(j.ctx, j.conditions, j.chk.GetRow(0))
+ matched, err = expression.EvalBool(j.ctx, j.conditions, j.mutRow.ToRow())
  if err != nil {
  return false, errors.Trace(err)
  }
@@ -252,10 +252,9 @@ func (j *leftOuterSemiJoiner) tryToMatch(outer chunk.Row, inners chunk.Iterator,
  }
 
  for inner := inners.Current(); inner != inners.End(); inner = inners.Next() {
- j.chk.Reset()
- j.makeJoinRowToChunk(j.chk, outer, inner)
+ j.makeJoinRow(false, inner, outer)
 
- matched, err = expression.EvalBool(j.ctx, j.conditions, j.chk.GetRow(0))
+ matched, err = expression.EvalBool(j.ctx, j.conditions, j.mutRow.ToRow())
  if err != nil {
  return false, errors.Trace(err)
  }
@@ -295,10 +294,9 @@ func (j *antiLeftOuterSemiJoiner) tryToMatch(outer chunk.Row, inners chunk.Itera
  }
 
  for inner := inners.Current(); inner != inners.End(); inner = inners.Next() {
- j.chk.Reset()
- j.makeJoinRowToChunk(j.chk, outer, inner)
- matched, err := expression.EvalBool(j.ctx, j.conditions, j.chk.GetRow(0))
+ j.makeJoinRow(false, inner, outer)
 
+ matched, err := expression.EvalBool(j.ctx, j.conditions, j.mutRow.ToRow())
  if err != nil {
  return false, errors.Trace(err)
  }
@@ -330,25 +328,7 @@ func (j *leftOuterJoiner) tryToMatch(outer chunk.Row, inners chunk.Iterator, chk
  if inners.Len() == 0 {
  return false, nil
  }
-
- j.chk.Reset()
- chkForJoin := j.chk
- if len(j.conditions) == 0 {
- chkForJoin = chk
- }
-
- numToAppend := j.maxChunkSize - chk.NumRows()
- for ; inners.Current() != inners.End() && numToAppend > 0; numToAppend-- {
- j.makeJoinRowToChunk(chkForJoin, outer, inners.Current())
- inners.Next()
- }
- if len(j.conditions) == 0 {
- return true, nil
- }
-
- // reach here, chkForJoin is j.chk
- matched, err := j.filter(chkForJoin, chk)
- return matched, errors.Trace(err)
+ return j.tryToMatchInnerAndOuter(false, outer, inners, chk)
 }
 
 func (j *leftOuterJoiner) onMissMatch(outer chunk.Row, chk *chunk.Chunk) {
@@ -366,24 +346,7 @@ func (j *rightOuterJoiner) tryToMatch(outer chunk.Row, inners chunk.Iterator, ch
  return false, nil
  }
 
- j.chk.Reset()
- chkForJoin := j.chk
- if len(j.conditions) == 0 {
- chkForJoin = chk
- }
-
- numToAppend := j.maxChunkSize - chk.NumRows()
- for ; inners.Current() != inners.End() && numToAppend > 0; numToAppend-- {
- j.makeJoinRowToChunk(chkForJoin, inners.Current(), outer)
- inners.Next()
- }
- if len(j.conditions) == 0 {
- return true, nil
- }
-
- // reach here, chkForJoin is j.chk
- matched, err := j.filter(chkForJoin, chk)
- return matched, errors.Trace(err)
+ return j.tryToMatchInnerAndOuter(true, outer, inners, chk)
 }
 
 func (j *rightOuterJoiner) onMissMatch(outer chunk.Row, chk *chunk.Chunk) {
@@ -400,26 +363,29 @@ func (j *innerJoiner) tryToMatch(outer chunk.Row, inners chunk.Iterator, chk *ch
  if inners.Len() == 0 {
  return false, nil
  }
- j.chk.Reset()
- chkForJoin := j.chk
- if len(j.conditions) == 0 {
- chkForJoin = chk
- }
- inner, numToAppend := inners.Current(), j.maxChunkSize-chk.NumRows()
- for ; inner != inners.End() && numToAppend > 0; inner, numToAppend = inners.Next(), numToAppend-1 {
- if j.outerIsRight {
- j.makeJoinRowToChunk(chkForJoin, inner, outer)
- } else {
- j.makeJoinRowToChunk(chkForJoin, outer, inner)
+
+ return j.tryToMatchInnerAndOuter(j.outerIsRight, outer, inners, chk)
+}
+
+// tryToMatchInnerAndOuter does 2 things:
+// 1. Combine outer and inner row to join row.
+// 2. Check whether the join row matches the join conditions, if so, append it to the `outChk`.
+func (j *baseJoiner) tryToMatchInnerAndOuter(isRight bool, outer chunk.Row, inners chunk.Iterator, outChk *chunk.Chunk) (bool, error) {
+ match := false
+ numToAppend := j.maxChunkSize - outChk.NumRows()
+ for inner := inners.Current(); inner != inners.End() && numToAppend > 0; inner, numToAppend = inners.Next(), numToAppend-1 {
+ j.makeJoinRow(isRight, inner, outer)
+
+ matched, err := expression.VectorizedFilterRow(j.ctx, j.conditions, j.mutRow.ToRow())
+ if err != nil {
+ return false, errors.Trace(err)
+ }
+ if matched {
+ match = true
+ outChk.AppendRow(j.mutRow.ToRow())
  }
  }
- if len(j.conditions) == 0 {
- return true, nil
- }
-
- // reach here, chkForJoin is j.chk
- matched, err := j.filter(chkForJoin, chk)
- return matched, errors.Trace(err)
+ return match, nil
 }
 
 func (j *innerJoiner) onMissMatch(outer chunk.Row, chk *chunk.Chunk) {

expression/chunk_executor.go

@@ -236,29 +236,37 @@ func VectorizedFilter(ctx sessionctx.Context, filters []Expression, iterator *ch
  for i, numRows := 0, iterator.Len(); i < numRows; i++ {
  selected = append(selected, true)
  }
- for _, filter := range filters {
- isIntType := true
- if filter.GetType().EvalType() != types.ETInt {
- isIntType = false
+ var err error
+ for row := iterator.Begin(); row != iterator.End(); row = iterator.Next() {
+ if !selected[row.Idx()] {
+ continue
+ }
+ selected[row.Idx()], err = VectorizedFilterRow(ctx, filters, row)
+ if err != nil {
+ return nil, errors.Trace(err)
  }
- for row := iterator.Begin(); row != iterator.End(); row = iterator.Next() {
- if !selected[row.Idx()] {
- continue
+ }
+ return selected, nil
+}
+
+// VectorizedFilterRow applies a list of filters to a row.
+func VectorizedFilterRow(ctx sessionctx.Context, filters []Expression, row chunk.Row) (bool, error) {
+ selected := true
+ for _, filter := range filters {
+ isTypeInt := filter.GetType().EvalType() == types.ETInt
+ if isTypeInt {
+ filterResult, isNull, err := filter.EvalInt(ctx, row)
+ if err != nil {
+ return false, errors.Trace(err)
  }
- if isIntType {
- filterResult, isNull, err := filter.EvalInt(ctx, row)
- if err != nil {
- return nil, errors.Trace(err)
- }
- selected[row.Idx()] = selected[row.Idx()] && !isNull && (filterResult != 0)
- } else {
- // TODO: should rewrite the filter to `cast(expr as SIGNED) != 0` and always use `EvalInt`.
- bVal, err := EvalBool(ctx, []Expression{filter}, row)
- if err != nil {
- return nil, errors.Trace(err)
- }
- selected[row.Idx()] = selected[row.Idx()] && bVal
+ selected = selected && !isNull && (filterResult != 0)
+ } else {
+ // TODO: should rewrite the filter to `cast(expr as SIGNED) != 0` and always use `EvalInt`.
+ bVal, err := EvalBool(ctx, []Expression{filter}, row)
+ if err != nil {
+ return false, errors.Trace(err)
  }
+ selected = selected && bVal
  }
  }
  return selected, nil