Fix linter errors from netquery implementation

netquery/orm/decoder.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log"
 	"reflect"
 	"strings"
 	"time"
@@ -30,7 +29,7 @@ var (
 	// TEXT or REAL.
 	// This package provides support for time.Time being stored as TEXT (using a
 	// preconfigured timezone; UTC by default) or as INTEGER (the user can choose between
-	// unixepoch and unixnano-epoch where the nano variant is not offically supported by
+	// unixepoch and unixnano-epoch where the nano variant is not officially supported by
 	// SQLITE).
 	SqliteTimeFormat = "2006-01-02 15:04:05"
 )
@@ -54,6 +53,7 @@ type (
 	// DecodeFunc is called for each non-basic type during decoding.
 	DecodeFunc func(colIdx int, colDef *ColumnDef, stmt Stmt, fieldDef reflect.StructField, outval reflect.Value) (interface{}, bool, error)
 
+	// DecodeConfig holds decoding functions.
 	DecodeConfig struct {
 		DecodeHooks []DecodeFunc
 	}
@@ -170,7 +170,8 @@ func DecodeStmt(ctx context.Context, schema *TableSchema, stmt Stmt, result inte
 			return fmt.Errorf("cannot decode column %d (type=%s)", i, colType)
 		}
 
-		//log.Printf("valueTypeName: %s fieldName = %s value-orig = %s value = %s (%v) newValue = %s", value.Type().String(), fieldName, target.FieldByName(fieldName).Type(), value.Type(), value, columnValue)
+		// Debugging:
+		// log.Printf("valueTypeName: %s fieldName = %s value-orig = %s value = %s (%v) newValue = %s", value.Type().String(), fieldName, target.FieldByName(fieldName).Type(), value.Type(), value, columnValue)
 
 		// convert it to the target type if conversion is possible
 		newValue := reflect.ValueOf(columnValue)
@@ -189,8 +190,7 @@ func DecodeStmt(ctx context.Context, schema *TableSchema, stmt Stmt, result inte
 // time.Time. For INTEGER storage classes, it supports 'unixnano' struct tag value to
 // decide between Unix or UnixNano epoch timestamps.
 //
-// FIXME(ppacher): update comment about loc parameter and TEXT storage class parsing
-//
+// TODO(ppacher): update comment about loc parameter and TEXT storage class parsing.
 func DatetimeDecoder(loc *time.Location) DecodeFunc {
 	return func(colIdx int, colDef *ColumnDef, stmt Stmt, fieldDef reflect.StructField, outval reflect.Value) (interface{}, bool, error) {
 		// if we have the column definition available we
@@ -203,11 +203,11 @@ func DatetimeDecoder(loc *time.Location) DecodeFunc {
 
 		// we only care about "time.Time" here
 		if outType.String() != "time.Time" || (colDef != nil && !colDef.IsTime) {
-			log.Printf("not decoding %s %v", outType, colDef)
+			// log.Printf("not decoding %s %v", outType, colDef)
 			return nil, false, nil
 		}
 
-		switch stmt.ColumnType(colIdx) {
+		switch stmt.ColumnType(colIdx) { //nolint:exhaustive // Only selecting specific types.
 		case sqlite.TypeInteger:
 			// stored as unix-epoch, if unixnano is set in the struct field tag
 			// we parse it with nano-second resolution
@@ -242,7 +242,7 @@ func DatetimeDecoder(loc *time.Location) DecodeFunc {
 	}
 }
 
-func decodeIntoMap(ctx context.Context, schema *TableSchema, stmt Stmt, mp *map[string]interface{}, cfg DecodeConfig) error {
+func decodeIntoMap(_ context.Context, schema *TableSchema, stmt Stmt, mp *map[string]interface{}, cfg DecodeConfig) error {
 	if *mp == nil {
 		*mp = make(map[string]interface{})
 	}
@@ -292,7 +292,7 @@ func decodeBasic() DecodeFunc {
 		if colDef != nil {
 			valueKind = normalizeKind(colDef.GoType.Kind())
 
-			// if we have a column defintion we try to convert the value to
+			// if we have a column definition we try to convert the value to
 			// the actual Go-type that was used in the model.
 			// this is useful, for example, to ensure a []byte{} is always decoded into json.RawMessage
 			// or that type aliases like (type myInt int) are decoded into myInt instead of int
@@ -314,7 +314,7 @@ func decodeBasic() DecodeFunc {
 			}()
 		}
 
-		log.Printf("decoding %s into kind %s", colName, valueKind)
+		// log.Printf("decoding %s into kind %s", colName, valueKind)
 
 		if colType == sqlite.TypeNull {
 			if colDef != nil && colDef.Nullable {
@@ -330,7 +330,7 @@ func decodeBasic() DecodeFunc {
 			}
 		}
 
-		switch valueKind {
+		switch valueKind { //nolint:exhaustive
 		case reflect.String:
 			if colType != sqlite.TypeText {
 				return nil, false, errInvalidType
@@ -455,7 +455,7 @@ func runDecodeHooks(colIdx int, colDef *ColumnDef, stmt Stmt, fieldDef reflect.S
 	return nil, nil
 }
 
-// getKind returns the kind of value but normalized Int, Uint and Float varaints
+// getKind returns the kind of value but normalized Int, Uint and Float variants.
 // to their base type.
 func getKind(val reflect.Value) reflect.Kind {
 	kind := val.Kind()
@@ -475,6 +475,7 @@ func normalizeKind(kind reflect.Kind) reflect.Kind {
 	}
 }
 
+// DefaultDecodeConfig holds the default decoding configuration.
 var DefaultDecodeConfig = DecodeConfig{
 	DecodeHooks: []DecodeFunc{
 		DatetimeDecoder(time.UTC),

netquery/orm/decoder_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"log"
 	"reflect"
 	"testing"
 	"time"
@@ -21,14 +20,14 @@ type testStmt struct {
 
 func (ts testStmt) ColumnCount() int                   { return len(ts.columns) }
 func (ts testStmt) ColumnName(i int) string            { return ts.columns[i] }
-func (ts testStmt) ColumnBool(i int) bool              { return ts.values[i].(bool) }
-func (ts testStmt) ColumnText(i int) string            { return ts.values[i].(string) }
-func (ts testStmt) ColumnFloat(i int) float64          { return ts.values[i].(float64) }
-func (ts testStmt) ColumnInt(i int) int                { return ts.values[i].(int) }
-func (ts testStmt) ColumnReader(i int) *bytes.Reader   { return bytes.NewReader(ts.values[i].([]byte)) }
+func (ts testStmt) ColumnBool(i int) bool              { return ts.values[i].(bool) }                    //nolint:forcetypeassert
+func (ts testStmt) ColumnText(i int) string            { return ts.values[i].(string) }                  //nolint:forcetypeassert
+func (ts testStmt) ColumnFloat(i int) float64          { return ts.values[i].(float64) }                 //nolint:forcetypeassert
+func (ts testStmt) ColumnInt(i int) int                { return ts.values[i].(int) }                     //nolint:forcetypeassert
+func (ts testStmt) ColumnReader(i int) *bytes.Reader   { return bytes.NewReader(ts.values[i].([]byte)) } //nolint:forcetypeassert
 func (ts testStmt) ColumnType(i int) sqlite.ColumnType { return ts.types[i] }
 
-// compile time check
+// Compile time check.
 var _ Stmt = new(testStmt)
 
 type exampleFieldTypes struct {
@@ -98,10 +97,11 @@ func (etn *exampleTimeNano) Equal(other interface{}) bool {
 	return etn.T.Equal(oetn.T)
 }
 
-func Test_Decoder(t *testing.T) {
-	ctx := context.TODO()
+func TestDecoder(t *testing.T) { //nolint:maintidx,tparallel
+	t.Parallel()
 
-	refTime := time.Date(2022, time.February, 15, 9, 51, 00, 00, time.UTC)
+	ctx := context.TODO()
+	refTime := time.Date(2022, time.February, 15, 9, 51, 0, 0, time.UTC)
 
 	cases := []struct {
 		Desc      string
@@ -433,8 +433,7 @@ func Test_Decoder(t *testing.T) {
 			nil,
 			&exampleInterface{},
 			func() interface{} {
-				var x interface{}
-				x = "value2"
+				var x interface{} = "value2"
 
 				return &exampleInterface{
 					I:  "value1",
@@ -546,12 +545,10 @@ func Test_Decoder(t *testing.T) {
 		},
 	}
 
-	for idx := range cases {
+	for idx := range cases { //nolint:paralleltest
 		c := cases[idx]
 		t.Run(c.Desc, func(t *testing.T) {
-			//t.Parallel()
-
-			log.Println(c.Desc)
+			// log.Println(c.Desc)
 			err := DecodeStmt(ctx, &TableSchema{Columns: c.ColumnDef}, c.Stmt, c.Result, DefaultDecodeConfig)
 			if fn, ok := c.Expected.(func() interface{}); ok {
 				c.Expected = fn()

netquery/orm/encoder.go

@@ -10,8 +10,10 @@ import (
 )
 
 type (
+	// EncodeFunc is called for each non-basic type during encoding.
 	EncodeFunc func(col *ColumnDef, valType reflect.Type, val reflect.Value) (interface{}, bool, error)
 
+	// EncodeConfig holds encoding functions.
 	EncodeConfig struct {
 		EncodeHooks []EncodeFunc
 	}
@@ -69,6 +71,7 @@ func ToParamMap(ctx context.Context, r interface{}, keyPrefix string, cfg Encode
 	return res, nil
 }
 
+// EncodeValue encodes the given value.
 func EncodeValue(ctx context.Context, colDef *ColumnDef, val interface{}, cfg EncodeConfig) (interface{}, error) {
 	fieldValue := reflect.ValueOf(val)
 	fieldType := reflect.TypeOf(val)
@@ -115,7 +118,7 @@ func encodeBasic() EncodeFunc {
 			val = val.Elem()
 		}
 
-		switch normalizeKind(kind) {
+		switch normalizeKind(kind) { //nolint:exhaustive
 		case reflect.String,
 			reflect.Float64,
 			reflect.Bool,
@@ -138,6 +141,7 @@ func encodeBasic() EncodeFunc {
 	}
 }
 
+// DatetimeEncoder returns a new datetime encoder for the given time zone.
 func DatetimeEncoder(loc *time.Location) EncodeFunc {
 	return func(colDef *ColumnDef, valType reflect.Type, val reflect.Value) (interface{}, bool, error) {
 		// if fieldType holds a pointer we need to dereference the value
@@ -149,7 +153,8 @@ func DatetimeEncoder(loc *time.Location) EncodeFunc {
 
 		// we only care about "time.Time" here
 		var t time.Time
-		if ft == "time.Time" {
+		switch {
+		case ft == "time.Time":
 			// handle the zero time as a NULL.
 			if !val.IsValid() || val.IsZero() {
 				return nil, true, nil
@@ -162,19 +167,19 @@ func DatetimeEncoder(loc *time.Location) EncodeFunc {
 				return nil, false, fmt.Errorf("cannot convert reflect value to time.Time")
 			}
 
-		} else if valType.Kind() == reflect.String && colDef.IsTime {
+		case valType.Kind() == reflect.String && colDef.IsTime:
 			var err error
 			t, err = time.Parse(time.RFC3339, val.String())
 			if err != nil {
 				return nil, false, fmt.Errorf("failed to parse time as RFC3339: %w", err)
 			}
 
-		} else {
+		default:
 			// we don't care ...
 			return nil, false, nil
 		}
 
-		switch colDef.Type {
+		switch colDef.Type { //nolint:exhaustive
 		case sqlite.TypeInteger:
 			if colDef.UnixNano {
 				return t.UnixNano(), true, nil
@@ -194,7 +199,7 @@ func DatetimeEncoder(loc *time.Location) EncodeFunc {
 func runEncodeHooks(colDef *ColumnDef, valType reflect.Type, val reflect.Value, hooks []EncodeFunc) (interface{}, bool, error) {
 	if valType == nil {
 		if !colDef.Nullable {
-			switch colDef.Type {
+			switch colDef.Type { //nolint:exhaustive
 			case sqlite.TypeBlob:
 				return []byte{}, true, nil
 			case sqlite.TypeFloat:
@@ -225,6 +230,7 @@ func runEncodeHooks(colDef *ColumnDef, valType reflect.Type, val reflect.Value,
 	return nil, false, nil
 }
 
+// DefaultEncodeConfig holds the default encoding configuration.
 var DefaultEncodeConfig = EncodeConfig{
 	EncodeHooks: []EncodeFunc{
 		DatetimeEncoder(time.UTC),

netquery/orm/encoder_test.go

@@ -9,9 +9,11 @@ import (
 	"zombiezen.com/go/sqlite"
 )
 
-func Test_EncodeAsMap(t *testing.T) {
+func TestEncodeAsMap(t *testing.T) { //nolint:tparallel
+	t.Parallel()
+
 	ctx := context.TODO()
-	refTime := time.Date(2022, time.February, 15, 9, 51, 00, 00, time.UTC)
+	refTime := time.Date(2022, time.February, 15, 9, 51, 0, 0, time.UTC)
 
 	cases := []struct {
 		Desc     string
@@ -114,11 +116,9 @@ func Test_EncodeAsMap(t *testing.T) {
 		},
 	}
 
-	for idx := range cases {
+	for idx := range cases { //nolint:paralleltest
 		c := cases[idx]
 		t.Run(c.Desc, func(t *testing.T) {
-			// t.Parallel()
-
 			res, err := ToParamMap(ctx, c.Input, "", DefaultEncodeConfig)
 			assert.NoError(t, err)
 			assert.Equal(t, c.Expected, res)
@@ -126,9 +126,11 @@ func Test_EncodeAsMap(t *testing.T) {
 	}
 }
 
-func Test_EncodeValue(t *testing.T) {
+func TestEncodeValue(t *testing.T) { //nolint:tparallel
+	t.Parallel()
+
 	ctx := context.TODO()
-	refTime := time.Date(2022, time.February, 15, 9, 51, 00, 00, time.UTC)
+	refTime := time.Date(2022, time.February, 15, 9, 51, 0, 0, time.UTC)
 
 	cases := []struct {
 		Desc   string
@@ -247,11 +249,9 @@ func Test_EncodeValue(t *testing.T) {
 		},
 	}
 
-	for idx := range cases {
+	for idx := range cases { //nolint:paralleltest
 		c := cases[idx]
 		t.Run(c.Desc, func(t *testing.T) {
-			//t.Parallel()
-
 			res, err := EncodeValue(ctx, &c.Column, c.Input, DefaultEncodeConfig)
 			assert.NoError(t, err)
 			assert.Equal(t, c.Output, res)

netquery/orm/query_runner.go

@@ -57,6 +57,8 @@ func WithNamedArgs(args map[string]interface{}) QueryOption {
 	}
 }
 
+// WithSchema returns a query option that adds the given table
+// schema to the query.
 func WithSchema(tbl TableSchema) QueryOption {
 	return func(opts *queryOpts) {
 		opts.Schema = tbl
@@ -139,9 +141,7 @@ func RunQuery(ctx context.Context, conn *sqlite.Conn, sql string, modifiers ...Q
 		valElemType = valType.Elem()
 
 		opts.ResultFunc = func(stmt *sqlite.Stmt) error {
-			var currentField reflect.Value
-
-			currentField = reflect.New(valElemType)
+			currentField := reflect.New(valElemType)
 
 			if err := DecodeStmt(ctx, &args.Schema, stmt, currentField.Interface(), args.DecodeConfig); err != nil {
 				return err

netquery/orm/schema_builder.go

@@ -10,10 +10,9 @@ import (
 	"zombiezen.com/go/sqlite"
 )
 
-var (
-	errSkipStructField = errors.New("struct field should be skipped")
-)
+var errSkipStructField = errors.New("struct field should be skipped")
 
+// Struct Tags.
 var (
 	TagUnixNano          = "unixnano"
 	TagPrimaryKey        = "primary"
@@ -36,12 +35,14 @@ var sqlTypeMap = map[sqlite.ColumnType]string{
 }
 
 type (
+	// TableSchema defines a SQL table schema.
 	TableSchema struct {
 		Name    string
 		Columns []ColumnDef
 	}
 
-	ColumnDef struct {
+	// ColumnDef defines a SQL column.
+	ColumnDef struct { //nolint:maligned
 		Name          string
 		Nullable      bool
 		Type          sqlite.ColumnType
@@ -54,6 +55,7 @@ type (
 	}
 )
 
+// GetColumnDef returns the column definition with the given name.
 func (ts TableSchema) GetColumnDef(name string) *ColumnDef {
 	for _, def := range ts.Columns {
 		if def.Name == name {
@@ -63,6 +65,7 @@ func (ts TableSchema) GetColumnDef(name string) *ColumnDef {
 	return nil
 }
 
+// CreateStatement build the CREATE SQL statement for the table.
 func (ts TableSchema) CreateStatement(ifNotExists bool) string {
 	sql := "CREATE TABLE"
 	if ifNotExists {
@@ -81,6 +84,7 @@ func (ts TableSchema) CreateStatement(ifNotExists bool) string {
 	return sql
 }
 
+// AsSQL builds the SQL column definition.
 func (def ColumnDef) AsSQL() string {
 	sql := def.Name + " "
 
@@ -103,6 +107,7 @@ func (def ColumnDef) AsSQL() string {
 	return sql
 }
 
+// GenerateTableSchema generates a table schema from the given struct.
 func GenerateTableSchema(name string, d interface{}) (*TableSchema, error) {
 	ts := &TableSchema{
 		Name: name,
@@ -149,7 +154,7 @@ func getColumnDef(fieldType reflect.StructField) (*ColumnDef, error) {
 	def.GoType = ft
 	kind := normalizeKind(ft.Kind())
 
-	switch kind {
+	switch kind { //nolint:exhaustive
 	case reflect.Int:
 		def.Type = sqlite.TypeInteger
 
@@ -190,7 +195,7 @@ func applyStructFieldTag(fieldType reflect.StructField, def *ColumnDef) error {
 	if len(parts) > 1 {
 		for _, k := range parts[1:] {
 			switch k {
-			// column modifieres
+			// column modifiers
 			case TagPrimaryKey:
 				def.PrimaryKey = true
 			case TagAutoIncrement:

netquery/orm/schema_builder_test.go

@@ -6,7 +6,9 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func Test_SchemaBuilder(t *testing.T) {
+func TestSchemaBuilder(t *testing.T) {
+	t.Parallel()
+
 	cases := []struct {
 		Name        string
 		Model       interface{}