MM-24312: Fix Dependency updates (#14391)

Automatic Merge

vendor/github.com/Masterminds/squirrel/expr.go

@@ -1,9 +1,9 @@
 package squirrel
 
 import (
+	"bytes"
 	"database/sql/driver"
 	"fmt"
-	"io"
 	"reflect"
 	"sort"
 	"strings"
@@ -20,35 +20,95 @@ type expr struct {
 	args []interface{}
 }
 
-// Expr builds value expressions for InsertBuilder and UpdateBuilder.
+// Expr builds an expression from a SQL fragment and arguments.
 //
 // Ex:
-//     .Values(Expr("FROM_UNIXTIME(?)", t))
+//     Expr("FROM_UNIXTIME(?)", t)
 func Expr(sql string, args ...interface{}) expr {
 	return expr{sql: sql, args: args}
 }
 
 func (e expr) ToSql() (sql string, args []interface{}, err error) {
-	return e.sql, e.args, nil
+	simple := true
+	for _, arg := range e.args {
+		if _, ok := arg.(Sqlizer); ok {
+			simple = false
+		}
+	}
+	if simple {
+		return e.sql, e.args, nil
+	}
+
+	buf := &bytes.Buffer{}
+	ap := e.args
+	sp := e.sql
+
+	var isql string
+	var iargs []interface{}
+
+	for err == nil && len(ap) > 0 && len(sp) > 0 {
+		i := strings.Index(sp, "?")
+		if i < 0 {
+			// no more placeholders
+			break
+		}
+		if len(sp) > i+1 && sp[i+1:i+2] == "?" {
+			// escaped "??"; append it and step past
+			buf.WriteString(sp[:i+2])
+			sp = sp[i+2:]
+			continue
+		}
+
+		if as, ok := ap[0].(Sqlizer); ok {
+			// sqlizer argument; expand it and append the result
+			isql, iargs, err = as.ToSql()
+			buf.WriteString(sp[:i])
+			buf.WriteString(isql)
+			args = append(args, iargs...)
+		} else {
+			// normal argument; append it and the placeholder
+			buf.WriteString(sp[:i+1])
+			args = append(args, ap[0])
+		}
+
+		// step past the argument and placeholder
+		ap = ap[1:]
+		sp = sp[i+1:]
+	}
+
+	// append the remaining sql and arguments
+	buf.WriteString(sp)
+	return buf.String(), append(args, ap...), err
 }
 
-type exprs []expr
+type concatExpr []interface{}
 
-func (es exprs) AppendToSql(w io.Writer, sep string, args []interface{}) ([]interface{}, error) {
-	for i, e := range es {
-		if i > 0 {
-			_, err := io.WriteString(w, sep)
+func (ce concatExpr) ToSql() (sql string, args []interface{}, err error) {
+	for _, part := range ce {
+		switch p := part.(type) {
+		case string:
+			sql += p
+		case Sqlizer:
+			pSql, pArgs, err := p.ToSql()
 			if err != nil {
-				return nil, err
+				return "", nil, err
 			}
+			sql += pSql
+			args = append(args, pArgs...)
+		default:
+			return "", nil, fmt.Errorf("%#v is not a string or Sqlizer", part)
 		}
-		_, err := io.WriteString(w, e.sql)
-		if err != nil {
-			return nil, err
-		}
-		args = append(args, e.args...)
 	}
-	return args, nil
+	return
+}
+
+// ConcatExpr builds an expression by concatenating strings and other expressions.
+//
+// Ex:
+//     name_expr := Expr("CONCAT(?, ' ', ?)", firstName, lastName)
+//     ConcatExpr("COALESCE(full_name,", name_expr, ")")
+func ConcatExpr(parts ...interface{}) concatExpr {
+	return concatExpr(parts)
 }
 
 // aliasExpr helps to alias part of SQL query generated with underlying "expr"
@@ -166,16 +226,8 @@ func (neq NotEq) ToSql() (sql string, args []interface{}, err error) {
 //     .Where(Like{"name": "%irrel"})
 type Like map[string]interface{}
 
-func (lk Like) toSql(opposite bool) (sql string, args []interface{}, err error) {
-	var (
-		exprs []string
-		opr   = "LIKE"
-	)
-
-	if opposite {
-		opr = "NOT LIKE"
-	}
-
+func (lk Like) toSql(opr string) (sql string, args []interface{}, err error) {
+	var exprs []string
 	for key, val := range lk {
 		expr := ""
 
@@ -205,7 +257,7 @@ func (lk Like) toSql(opposite bool) (sql string, args []interface{}, err error)
 }
 
 func (lk Like) ToSql() (sql string, args []interface{}, err error) {
-	return lk.toSql(false)
+	return lk.toSql("LIKE")
 }
 
 // NotLike is syntactic sugar for use with LIKE conditions.
@@ -214,7 +266,25 @@ func (lk Like) ToSql() (sql string, args []interface{}, err error) {
 type NotLike Like
 
 func (nlk NotLike) ToSql() (sql string, args []interface{}, err error) {
-	return Like(nlk).toSql(true)
+	return Like(nlk).toSql("NOT LIKE")
+}
+
+// ILike is syntactic sugar for use with ILIKE conditions.
+// Ex:
+//    .Where(ILike{"name": "sq%"})
+type ILike Like
+
+func (ilk ILike) ToSql() (sql string, args []interface{}, err error) {
+	return Like(ilk).toSql("ILIKE")
+}
+
+// NotILike is syntactic sugar for use with ILIKE conditions.
+// Ex:
+//    .Where(NotILike{"name": "sq%"})
+type NotILike Like
+
+func (nilk NotILike) ToSql() (sql string, args []interface{}, err error) {
+	return Like(nilk).toSql("NOT ILIKE")
 }
 
 // Lt is syntactic sugar for use with Where/Having/Set methods.