Revert "clean up func getPkValueExpr" (#14522)

Reverts #14378

Author: sukki37

pkg/sql/plan/build_constraint_util.go

@@ -210,14 +210,14 @@ func setTableExprToDmlTableInfo(ctx CompilerContext, tbl tree.TableExpr, tblInfo
 		tbl = aliasTbl.Expr
 	}
 
-	if joinTbl, ok := tbl.(*tree.JoinTableExpr); ok {
+	if jionTbl, ok := tbl.(*tree.JoinTableExpr); ok {
 		tblInfo.needAggFilter = true
-		err := setTableExprToDmlTableInfo(ctx, joinTbl.Left, tblInfo, aliasMap, withMap)
+		err := setTableExprToDmlTableInfo(ctx, jionTbl.Left, tblInfo, aliasMap, withMap)
 		if err != nil {
 			return err
 		}
-		if joinTbl.Right != nil {
-			return setTableExprToDmlTableInfo(ctx, joinTbl.Right, tblInfo, aliasMap, withMap)
+		if jionTbl.Right != nil {
+			return setTableExprToDmlTableInfo(ctx, jionTbl.Right, tblInfo, aliasMap, withMap)
 		}
 		return nil
 	}

pkg/sql/plan/build_insert.go

@@ -301,8 +301,6 @@ func getPkValueExpr(builder *QueryBuilder, ctx CompilerContext, tableDef *TableD
 	var insertRowIdx int
 	var pkColIdx int
 
-	// handles UUID types specifically by creating a VARCHAR type and casting the UUID to a string.
-	// If the expression is nil, it creates a constant expression with either the UUID value or a constant value.
 	for insertRowIdx, pkColIdx = range pkPosInValues {
 		valExprs := make([]*Expr, rowsCount)
 		rowTyp := bat.Vecs[insertRowIdx].GetType()
@@ -360,35 +358,7 @@ func getPkValueExpr(builder *QueryBuilder, ctx CompilerContext, tableDef *TableD
 	}
 
 	if pkColLength == 1 {
-		if rowsCount <= 3 {
-			// pk = a1 or pk = a2 or pk = a3
-			var orExpr *Expr
-			for i := 0; i < rowsCount; i++ {
-				expr, err := BindFuncExprImplByPlanExpr(builder.GetContext(), "=", []*Expr{{
-					Typ: colTyp,
-					Expr: &plan.Expr_Col{
-						Col: &ColRef{
-							ColPos: int32(pkColIdx),
-							Name:   tableDef.Pkey.PkeyColName,
-						},
-					},
-				}, colExprs[0][i]})
-				if err != nil {
-					return nil
-				}
-
-				if i == 0 {
-					orExpr = expr
-				} else {
-					orExpr, err = BindFuncExprImplByPlanExpr(builder.GetContext(), "or", []*Expr{orExpr, expr})
-					if err != nil {
-						return nil
-					}
-				}
-			}
-			return []*Expr{orExpr}
-		} else {
-			// pk in (a1, a2, a3)
+		if rowsCount > 1 {
 			// args in list must be constant
 			expr, err := BindFuncExprImplByPlanExpr(builder.GetContext(), "in", []*Expr{{
 				Typ: colTyp,
@@ -416,13 +386,58 @@ func getPkValueExpr(builder *QueryBuilder, ctx CompilerContext, tableDef *TableD
 				return nil
 			}
 			return []*Expr{expr}
+		} else {
+			var orExpr *Expr
+			for i := 0; i < rowsCount; i++ {
+				expr, err := BindFuncExprImplByPlanExpr(builder.GetContext(), "=", []*Expr{{
+					Typ: colTyp,
+					Expr: &plan.Expr_Col{
+						Col: &ColRef{
+							ColPos: int32(pkColIdx),
+							Name:   tableDef.Pkey.PkeyColName,
+						},
+					},
+				}, colExprs[0][i]})
+				if err != nil {
+					return nil
+				}
+
+				if i == 0 {
+					orExpr = expr
+				} else {
+					orExpr, err = BindFuncExprImplByPlanExpr(builder.GetContext(), "or", []*Expr{orExpr, expr})
+					if err != nil {
+						return nil
+					}
+				}
+			}
+			return []*Expr{orExpr}
 		}
 	} else {
-		var orExpr *Expr
-		if rowsCount <= 3 {
-			// ppk1 = a1 and ppk2 = a2 or ppk1 = b1 and ppk2 = b2 or ppk1 = c1 and ppk2 = c2
-			var andExpr *Expr
+		// multi cols pk & one row for insert
+		if rowsCount == 1 {
+			filterExprs := make([]*Expr, pkColLength)
+			for insertRowIdx, pkColIdx = range pkPosInValues {
+				expr, err := BindFuncExprImplByPlanExpr(builder.GetContext(), "=", []*Expr{{
+					Typ: tableDef.Cols[insertRowIdx].Typ,
+					Expr: &plan.Expr_Col{
+						Col: &ColRef{
+							ColPos: int32(pkColIdx),
+							Name:   tableDef.Cols[insertRowIdx].Name,
+						},
+					},
+				}, colExprs[pkColIdx][0]})
+				if err != nil {
+					return nil
+				}
+				filterExprs[pkColIdx] = expr
+			}
+			return filterExprs
+		} else {
+			// seems serial function have poor performance. we have to use or function
+			var orExpr *Expr
 			for i := 0; i < rowsCount; i++ {
+				var andExpr *Expr
 				for insertRowIdx, pkColIdx = range pkPosInValues {
 					eqExpr, err := BindFuncExprImplByPlanExpr(builder.GetContext(), "=", []*Expr{{
 						Typ: tableDef.Cols[insertRowIdx].Typ,
@@ -436,6 +451,7 @@ func getPkValueExpr(builder *QueryBuilder, ctx CompilerContext, tableDef *TableD
 					if err != nil {
 						return nil
 					}
+
 					if andExpr == nil {
 						andExpr = eqExpr
 					} else {
@@ -445,6 +461,7 @@ func getPkValueExpr(builder *QueryBuilder, ctx CompilerContext, tableDef *TableD
 						}
 					}
 				}
+
 				if i == 0 {
 					orExpr = andExpr
 				} else {
@@ -455,72 +472,6 @@ func getPkValueExpr(builder *QueryBuilder, ctx CompilerContext, tableDef *TableD
 				}
 			}
 			return []*Expr{orExpr}
-		} else {
-			//  __cpkey__ in (serial(a1,b1,c1,d1),serial(a2,b2,c2,d2),xxx)
-			inExprs := make([]*plan.Expr, rowsCount)
-
-			// serialize
-			for i := 0; i < rowsCount; i++ {
-				serExprs := make([]*plan.Expr, 0, len(pkPosInValues))
-				for insertRowIdx, pkColIdx := range pkPosInValues {
-					serExprs = append(serExprs, &plan.Expr{
-						Typ: tableDef.Cols[insertRowIdx].Typ,
-						Expr: &plan.Expr_Col{
-							Col: &ColRef{
-								ColPos: int32(pkColIdx),
-								Name:   tableDef.Cols[insertRowIdx].Name,
-							},
-						},
-					})
-				}
-				cpk, err := BindFuncExprImplByPlanExpr(builder.GetContext(), "serial", []*Expr{
-					{
-						Expr: &plan.Expr_List{
-							List: &plan.ExprList{
-								List: serExprs,
-							},
-						},
-						Typ: &plan.Type{
-							Id: int32(types.T_tuple),
-						},
-					},
-				})
-				if err != nil {
-					return nil
-				}
-				inExprs[i] = cpk
-			}
-
-			expr, err := BindFuncExprImplByPlanExpr(builder.GetContext(), "in", []*Expr{
-				{
-					Typ: colTyp,
-					Expr: &plan.Expr_Col{
-						Col: &ColRef{
-							ColPos: int32(len(pkPosInValues)),
-							Name:   tableDef.Pkey.PkeyColName,
-						},
-					},
-				}, {
-					Expr: &plan.Expr_List{
-						List: &plan.ExprList{
-							List: inExprs,
-						},
-					},
-					Typ: &plan.Type{
-						Id: int32(types.T_tuple),
-					},
-				},
-			})
-			if err != nil {
-				return nil
-			}
-
-			expr2, err := ConstantFold(batch.EmptyForConstFoldBatch, expr, proc, false)
-			if err != nil {
-				return nil
-			}
-
-			return []*Expr{expr2}
 		}
 	}
 }