Update Lint stage in workflow, fix lint issues

The Lint stage has been failing consistently due to a deprecated
version of golangci-lint-action.

Author: ido50

.github/workflows/build.yml

@@ -17,7 +17,7 @@ jobs:
       uses: actions/setup-go@v2
       id: go
       with:
-        go-version: ^1.14
+        go-version: ^1.15
 
     - name: Check out code into the Go module directory
       uses: actions/checkout@v2
@@ -32,6 +32,7 @@ jobs:
       run: go test -v .
 
     - name: Lint
-      uses: golangci/golangci-lint-action@v1.2.1
+      uses: golangci/golangci-lint-action@v3
       with:
-          version: v1.28
+        version: latest
+        only-new-issues: true

.golangci.yml

@@ -4,47 +4,43 @@ run:
 linters:
     disable-all: true
     enable:
-        - govet
-        - golint
-        - errcheck
-        - staticcheck
-        - unused
-        - gosimple
-        - structcheck
-        - varcheck
-        - ineffassign
-        - deadcode
-        - typecheck
-        - rowserrcheck
-        - stylecheck
-        - interfacer
-        - unconvert
+        - asciicheck
         - dupl
+        - errorlint
+        - errcheck
+        - exhaustive
+        - exportloopref
+        - funlen
+        - gocognit
         - goconst
+        - gocritic
         - gocyclo
-        - gocognit
-        - asciicheck
-        - goimports
+        - goerr113
         - goheader
-        - maligned
-        - misspell
+        - goimports
+        - gomnd
+        - goprintffuncname
+        - gosec
+        - gosimple
+        - govet
+        - ineffassign
         - lll
-        - unparam
+        - misspell
         - nakedret
+        - nestif
+        - nolintlint
         - prealloc
-        - scopelint
-        - gocritic
-        - funlen
+        - rowserrcheck
+        - sqlclosecheck
+        - staticcheck
+        - stylecheck
+        - typecheck
+        - unconvert
+        - unparam
+        - unused
+        - wastedassign
         - whitespace
         - wsl
-        - goprintffuncname
-        - gomnd
-        - goerr113
-        - nestif
-        - exportloopref
-        - exhaustive
-        - sqlclosecheck
-        - nolintlint
 linters-settings:
     funlen:
         lines: 150

doc.go

@@ -22,31 +22,31 @@
 // sqlz provides a comfortable API for running queries in a transaction, and
 // will automatically commit or rollback the transaction as necessary.
 //
-//		import (
-//			"fmt"
-//			"database/sql"
-//			"github.com/ido50/sqlz"
-//			_ "sql driver of choice"
-//		)
-//
-//		func main() {
-//			db, err := sql.Open(driver, "dsn")
-//			if err != nil {
-//				panic(err)
-//			}
-//
-//			// find one row in the database and load it
-//			// into a struct variable
-//			var row someStruct
-//			err = sqlz.New(db, driver).  // if using sqlx: sqlz.Newx(dbx)
-//				Select("*").
-//				From("some-table").
-//				Where(sqlz.Eq("id", 1)).
-//				GetRow(&row)
-//			if err != nil {
-//				panic(err)
-//			}
-//
-//			fmt.Printf("%+v\n", row)
+//	import (
+//		"fmt"
+//		"database/sql"
+//		"github.com/ido50/sqlz"
+//		_ "sql driver of choice"
+//	)
+//
+//	func main() {
+//		db, err := sql.Open(driver, "dsn")
+//		if err != nil {
+//			panic(err)
 //		}
+//
+//		// find one row in the database and load it
+//		// into a struct variable
+//		var row someStruct
+//		err = sqlz.New(db, driver).  // if using sqlx: sqlz.Newx(dbx)
+//			Select("*").
+//			From("some-table").
+//			Where(sqlz.Eq("id", 1)).
+//			GetRow(&row)
+//		if err != nil {
+//			panic(err)
+//		}
+//
+//		fmt.Printf("%+v\n", row)
+//	}
 package sqlz

select.go

@@ -377,8 +377,7 @@ func ForKeyShare() *LockClause {
 // ToSQL generates the SELECT statement's SQL and returns a list of
 // bindings. It is used internally by GetRow and GetAll, but is
 // exported if you wish to use it directly.
-// nolint: gocognit, gocyclo
-func (stmt *SelectStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{}) {
+func (stmt *SelectStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{}) { //nolint: gocognit, gocyclo
 	var clauses = []string{"SELECT"}
 
 	if stmt.IsDistinct {

select_test.go

@@ -54,9 +54,9 @@ func TestSelect(t *testing.T) {
 			{
 				"select with array comparisons",
 				dbz.Select("*").From("table").Where(EqAny("array_col", 3), GtAll("other_array_col", 1), NeAny("yet_another_col", Indirect("NOW()")),
-					Any(Indirect("column"),[]int{1,2,3})),
+					Any(Indirect("column"), []int{1, 2, 3})),
 				"SELECT * FROM table WHERE ? = ANY(array_col) AND ? > ALL(other_array_col) AND NOW() <> ANY(yet_another_col) AND column = ANY(?)",
-				[]interface{}{3, 1 ,"'{1,2,3}'"},
+				[]interface{}{3, 1, "'{1,2,3}'"},
 			},
 
 			{

set.go

@@ -56,15 +56,19 @@ func (tx *Tx) SetTimeout(d time.Duration) (res sql.Result, err error) {
 }
 
 // Local sets the configuration parameter locally in a transaction.
-//  The effect of SET LOCAL will last only till the end of the
+//
+//	The effect of SET LOCAL will last only till the end of the
+//
 // current transaction, whether committed or not.
 func (cmd *SetCmd) Local() *SetCmd {
 	cmd.level = "LOCAL"
 	return cmd
 }
 
 // Session sets the configuration parameter to the entire session.
-//  The effect of SET SESSION will last only till the end of the
+//
+//	The effect of SET SESSION will last only till the end of the
+//
 // current session. if issued within a transaction that is later aborted,
 // the effects of the SET command disappear when the transaction is rolled
 // back. Once the surrounding transaction is committed, the effects will persist

sqlz.go

@@ -92,7 +92,7 @@ func (db *DB) TransactionalContext(
 
 	err = f(&Tx{Tx: tx, ErrHandlers: db.ErrHandlers})
 	if err != nil {
-		tx.Rollback() // nolint: errcheck
+		tx.Rollback() //nolint: errcheck
 		return err
 	}
 

update.go

@@ -152,31 +152,14 @@ func (stmt *UpdateStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{}
 	if stmt.SelectStmt != nil && stmt.SelectStmtAlias != "" {
 		selectSQL, selectBindings := stmt.SelectStmt.ToSQL(false)
 		selectSQL = "(" + selectSQL + ") AS " + stmt.SelectStmtAlias + " "
+
 		clauses = append(clauses, "FROM ")
 		clauses = append(clauses, selectSQL)
 		bindings = append(bindings, selectBindings...)
 	} else if len(stmt.MultipleValues.Values) > 0 {
-		// add the FROM
-		clauses = append(clauses, "FROM")
-		var multipleValues []string
-		for _, multipleVals := range stmt.MultipleValues.Values {
-			placeholders, bindingsToAdd := parseInsertValues(multipleVals)
-			bindings = append(bindings, bindingsToAdd...)
-			multipleValues = append(multipleValues, "("+strings.Join(placeholders, ", ")+")")
-		}
-
-		clauses = append(clauses, fmt.Sprintf("(VALUES %s) AS %s(%s)",
-			strings.Join(multipleValues, ", "),
-			stmt.MultipleValues.As,
-			strings.Join(stmt.MultipleValues.Columns, ", "),
-		))
-
-		if len(stmt.MultipleValues.Where) > 0 {
-			whereClause, whereBindings := parseConditions(stmt.MultipleValues.Where)
-			bindings = append(bindings, whereBindings...)
-			clauses = append(clauses, fmt.Sprintf("WHERE %s", whereClause))
-		}
-
+		addClauses, addBindings := stmt.addUpdateFrom()
+		clauses = append(clauses, addClauses...)
+		bindings = append(bindings, addBindings...)
 	}
 
 	if len(stmt.Conditions) > 0 {
@@ -202,6 +185,35 @@ func (stmt *UpdateStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{}
 	return asSQL, bindings
 }
 
+func (stmt *UpdateStmt) addUpdateFrom() (
+	clauses []string,
+	bindings []interface{},
+) {
+	clauses = append(clauses, "FROM")
+
+	multipleValues := make([]string, len(stmt.MultipleValues.Values))
+
+	for i, multipleVals := range stmt.MultipleValues.Values {
+		placeholders, bindingsToAdd := parseInsertValues(multipleVals)
+		bindings = append(bindings, bindingsToAdd...)
+		multipleValues[i] = "(" + strings.Join(placeholders, ", ") + ")"
+	}
+
+	clauses = append(clauses, fmt.Sprintf("(VALUES %s) AS %s(%s)",
+		strings.Join(multipleValues, ", "),
+		stmt.MultipleValues.As,
+		strings.Join(stmt.MultipleValues.Columns, ", "),
+	))
+
+	if len(stmt.MultipleValues.Where) > 0 {
+		whereClause, whereBindings := parseConditions(stmt.MultipleValues.Where)
+		bindings = append(bindings, whereBindings...)
+		clauses = append(clauses, fmt.Sprintf("WHERE %s", whereClause))
+	}
+
+	return clauses, bindings
+}
+
 // Exec executes the UPDATE statement, returning the standard
 // sql.Result struct and an error if the query failed.
 func (stmt *UpdateStmt) Exec() (res sql.Result, err error) {