File repository.go has 794 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package rel

import (
    "context"
    "errors"

Function convertAssign has 136 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func convertAssign(dest, src interface{}) error {
    // Common cases, without reflect.
    switch s := src.(type) {
    case string:
        switch d := dest.(type) {

FilterQuery has 32 methods (exceeds 20 allowed). Consider refactoring.

Open

type FilterQuery struct {
    Type  FilterOp
    Field string
    Value interface{}
    Inner []FilterQuery

Function convertAssign has a Cognitive Complexity of 39 (exceeds 20 allowed). Consider refactoring.

Open

func convertAssign(dest, src interface{}) error {
    // Common cases, without reflect.
    switch s := src.(type) {
    case string:
        switch d := dest.(type) {

• Read up
  Read up

Builder has 28 methods (exceeds 20 allowed). Consider refactoring.

Open

type Builder struct {
    config      Config
    returnField string
    count       int
}

Query has 25 methods (exceeds 20 allowed). Consider refactoring.

Open

type Query struct {
    empty         bool // TODO: use bitmask to mark what is updated and use it when merging two queries
    Table         string
    SelectQuery   SelectQuery
    JoinQuery     []JoinQuery

Function preload has a Cognitive Complexity of 34 (exceeds 20 allowed). Consider refactoring.

Open

func preload(target slice, result slice, path []string) {
    type frame struct {
        index int
        doc   *rel.Document
    }

• Read up
  Read up

Function convertAssign has 28 return statements (exceeds 4 allowed).

Open

func convertAssign(dest, src interface{}) error {
    // Common cases, without reflect.
    switch s := src.(type) {
    case string:
        switch d := dest.(type) {

Document has 22 methods (exceeds 20 allowed). Consider refactoring.

Open

type Document struct {
    v    interface{}
    rv   reflect.Value
    rt   reflect.Type
    data documentData

Method repository.mapPreloadTargets has 77 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (r repository) mapPreloadTargets(sl slice, path []string) (map[interface{}][]slice, string, string, reflect.Type, documentData, bool) {
    type frame struct {
        index int
        doc   *Document
    }

Method repository.saveHasMany has 77 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (r repository) saveHasMany(cw contextWrapper, doc *Document, mutation *Mutation, insertion bool) error {
    for _, field := range doc.HasMany() {
        assocMuts, changed := mutation.Assoc[field]
        if !changed {
            continue

Function preload has 65 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func preload(target slice, result slice, path []string) {
    type frame struct {
        index int
        doc   *rel.Document
    }

Function extractAssociationData has 59 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func extractAssociationData(rt reflect.Type, index int) associationData {
    var (
        key = associationKey{
            rt:    rt,
            index: index,

Method Changeset.applyAssocMany has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (c Changeset) applyAssocMany(field string, mut *Mutation) {
    if chs, ok := c.assocMany[field]; ok {
        var (
            assoc      = c.doc.Association(field)
            col, _     = assoc.Collection()

• Read up
  Read up

Method Map.Apply has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (m Map) Apply(doc *Document, mutation *Mutation) {
    var (
        pField = doc.PrimaryField()
        pValue = doc.PrimaryValue()
    )

• Read up
  Read up

Method repository.update has 7 return statements (exceeds 4 allowed).

Open

func (r repository) update(cw contextWrapper, doc *Document, mutation Mutation, filter FilterQuery) error {
    if mutation.Cascade {
        if err := r.saveBelongsTo(cw, doc, &mutation); err != nil {
            return err
        }

Method repository.insert has 6 return statements (exceeds 4 allowed).

Open

func (r repository) insert(cw contextWrapper, doc *Document, mutation Mutation) error {
    var (
        pField   string
        pFields  = doc.PrimaryFields()
        queriers = Build(doc.Table())

Method repository.saveHasMany has 6 return statements (exceeds 4 allowed).

Open

func (r repository) saveHasMany(cw contextWrapper, doc *Document, mutation *Mutation, insertion bool) error {
    for _, field := range doc.HasMany() {
        assocMuts, changed := mutation.Assoc[field]
        if !changed {
            continue

Function isDeepZero has 6 return statements (exceeds 4 allowed).

Open

func isDeepZero(rv reflect.Value, depth int) bool {
    if depth < 0 {
        return true
    }

Function QuickExample has 5 return statements (exceeds 4 allowed).

Open

func QuickExample(ctx context.Context, repo rel.Repository) error {
    /// [quick-example]
    book := Book{Title: "REL for Dummies"}

    // Insert a Book.