documents.go

// Code generated by SQLBoiler 4.11.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT.
// This file is meant to be re-generated in place and/or deleted at any time.

package repository

import (
	"context"
	"database/sql"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/friendsofgo/errors"
	"github.com/volatiletech/null/v8"
	"github.com/volatiletech/sqlboiler/v4/boil"
	"github.com/volatiletech/sqlboiler/v4/queries"
	"github.com/volatiletech/sqlboiler/v4/queries/qm"
	"github.com/volatiletech/sqlboiler/v4/queries/qmhelper"
	"github.com/volatiletech/strmangle"
)

// Document is an object representing the database table.
type Document struct {
	L              documentL  `boil:"-" json:"-" toml:"-" yaml:"-"`
	CreatedAt      time.Time  `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
	UpdatedAt      time.Time  `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`
	R              *documentR `boil:"-" json:"-" toml:"-" yaml:"-"`
	DeletedAt      null.Time  `boil:"deleted_at" json:"deleted_at,omitempty" toml:"deleted_at" yaml:"deleted_at,omitempty"`
	Path           string     `boil:"path" json:"path" toml:"path" yaml:"path"`
	DocumentTypeID null.Int64 `boil:"document_type_id" json:"document_type_id,omitempty" toml:"document_type_id" yaml:"document_type_id,omitempty"`
	ID             int64      `boil:"id" json:"id" toml:"id" yaml:"id"`
}

var DocumentColumns = struct {
	ID             string
	Path           string
	DocumentTypeID string
	CreatedAt      string
	UpdatedAt      string
	DeletedAt      string
}{
	ID:             "id",
	Path:           "path",
	DocumentTypeID: "document_type_id",
	CreatedAt:      "created_at",
	UpdatedAt:      "updated_at",
	DeletedAt:      "deleted_at",
}

var DocumentTableColumns = struct {
	ID             string
	Path           string
	DocumentTypeID string
	CreatedAt      string
	UpdatedAt      string
	DeletedAt      string
}{
	ID:             "documents.id",
	Path:           "documents.path",
	DocumentTypeID: "documents.document_type_id",
	CreatedAt:      "documents.created_at",
	UpdatedAt:      "documents.updated_at",
	DeletedAt:      "documents.deleted_at",
}

// Generated where

var DocumentWhere = struct {
	ID             whereHelperint64
	Path           whereHelperstring
	DocumentTypeID whereHelpernull_Int64
	CreatedAt      whereHelpertime_Time
	UpdatedAt      whereHelpertime_Time
	DeletedAt      whereHelpernull_Time
}{
	ID:             whereHelperint64{field: "[dbo].[documents].[id]"},
	Path:           whereHelperstring{field: "[dbo].[documents].[path]"},
	DocumentTypeID: whereHelpernull_Int64{field: "[dbo].[documents].[document_type_id]"},
	CreatedAt:      whereHelpertime_Time{field: "[dbo].[documents].[created_at]"},
	UpdatedAt:      whereHelpertime_Time{field: "[dbo].[documents].[updated_at]"},
	DeletedAt:      whereHelpernull_Time{field: "[dbo].[documents].[deleted_at]"},
}

// DocumentRels is where relationship names are stored.
var DocumentRels = struct {
	DocumentType         string
	Tags                 string
	SourceDocuments      string
	DestinationDocuments string
}{
	DocumentType:         "DocumentType",
	Tags:                 "Tags",
	SourceDocuments:      "SourceDocuments",
	DestinationDocuments: "DestinationDocuments",
}

// documentR is where relationships are stored.
type documentR struct {
	DocumentType         *DocumentType `boil:"DocumentType" json:"DocumentType" toml:"DocumentType" yaml:"DocumentType"`
	Tags                 TagSlice      `boil:"Tags" json:"Tags" toml:"Tags" yaml:"Tags"`
	SourceDocuments      DocumentSlice `boil:"SourceDocuments" json:"SourceDocuments" toml:"SourceDocuments" yaml:"SourceDocuments"`
	DestinationDocuments DocumentSlice `boil:"DestinationDocuments" json:"DestinationDocuments" toml:"DestinationDocuments" yaml:"DestinationDocuments"`
}

// NewStruct creates a new relationship struct
func (*documentR) NewStruct() *documentR {
	return &documentR{}
}

func (r *documentR) GetDocumentType() *DocumentType {
	if r == nil {
		return nil
	}
	return r.DocumentType
}

func (r *documentR) GetTags() TagSlice {
	if r == nil {
		return nil
	}
	return r.Tags
}

func (r *documentR) GetSourceDocuments() DocumentSlice {
	if r == nil {
		return nil
	}
	return r.SourceDocuments
}

func (r *documentR) GetDestinationDocuments() DocumentSlice {
	if r == nil {
		return nil
	}
	return r.DestinationDocuments
}

// documentL is where Load methods for each relationship are stored.
type documentL struct{}

var (
	documentAllColumns            = []string{"id", "path", "document_type_id", "created_at", "updated_at", "deleted_at"}
	documentColumnsWithoutDefault = []string{"id", "path", "document_type_id", "created_at", "updated_at", "deleted_at"}
	documentColumnsWithDefault    = []string{}
	documentPrimaryKeyColumns     = []string{"id"}
	documentGeneratedColumns      =[]string{}
)

type (
	// DocumentSlice is an alias for a slice of pointers to Document.
	// This should almost always be used instead of []Document.
	DocumentSlice []*Document
	// DocumentHook is the signature for custom Document hook methods
	DocumentHook func(context.Context, boil.ContextExecutor, *Document) error

	documentQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	documentType                 = reflect.TypeOf(&Document{})
	documentMapping              = queries.MakeStructMapping(documentType)
	documentPrimaryKeyMapping, _ = queries.BindMapping(documentType, documentMapping, documentPrimaryKeyColumns)
	documentInsertCacheMut       sync.RWMutex
	documentInsertCache          = make(map[string]insertCache)
	documentUpdateCacheMut       sync.RWMutex
	documentUpdateCache          = make(map[string]updateCache)
	documentUpsertCacheMut       sync.RWMutex
	documentUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force qmhelper dependency for where clause generation (which doesn't
	// always happen)
	_ = qmhelper.Where
)

var documentAfterSelectHooks []DocumentHook

var documentBeforeInsertHooks []DocumentHook
var documentAfterInsertHooks []DocumentHook

var documentBeforeUpdateHooks []DocumentHook
var documentAfterUpdateHooks []DocumentHook

var documentBeforeDeleteHooks []DocumentHook
var documentAfterDeleteHooks []DocumentHook

var documentBeforeUpsertHooks []DocumentHook
var documentAfterUpsertHooks []DocumentHook

// doAfterSelectHooks executes all "after Select" hooks.
func (o *Document) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentAfterSelectHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doBeforeInsertHooks executes all "before insert" hooks.
func (o *Document) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentBeforeInsertHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doAfterInsertHooks executes all "after Insert" hooks.
func (o *Document) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentAfterInsertHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doBeforeUpdateHooks executes all "before Update" hooks.
func (o *Document) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentBeforeUpdateHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doAfterUpdateHooks executes all "after Update" hooks.
func (o *Document) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentAfterUpdateHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doBeforeDeleteHooks executes all "before Delete" hooks.
func (o *Document) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentBeforeDeleteHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doAfterDeleteHooks executes all "after Delete" hooks.
func (o *Document) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentAfterDeleteHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doBeforeUpsertHooks executes all "before Upsert" hooks.
func (o *Document) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentBeforeUpsertHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doAfterUpsertHooks executes all "after Upsert" hooks.
func (o *Document) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range documentAfterUpsertHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// AddDocumentHook registers your hook function for all future operations.
func AddDocumentHook(hookPoint boil.HookPoint, documentHook DocumentHook) {
	switch hookPoint {
	case boil.AfterSelectHook:
		documentAfterSelectHooks = append(documentAfterSelectHooks, documentHook)
	case boil.BeforeInsertHook:
		documentBeforeInsertHooks = append(documentBeforeInsertHooks, documentHook)
	case boil.AfterInsertHook:
		documentAfterInsertHooks = append(documentAfterInsertHooks, documentHook)
	case boil.BeforeUpdateHook:
		documentBeforeUpdateHooks = append(documentBeforeUpdateHooks, documentHook)
	case boil.AfterUpdateHook:
		documentAfterUpdateHooks = append(documentAfterUpdateHooks, documentHook)
	case boil.BeforeDeleteHook:
		documentBeforeDeleteHooks = append(documentBeforeDeleteHooks, documentHook)
	case boil.AfterDeleteHook:
		documentAfterDeleteHooks = append(documentAfterDeleteHooks, documentHook)
	case boil.BeforeUpsertHook:
		documentBeforeUpsertHooks = append(documentBeforeUpsertHooks, documentHook)
	case boil.AfterUpsertHook:
		documentAfterUpsertHooks = append(documentAfterUpsertHooks, documentHook)
	}
}

// One returns a single document record from the query.
func (q documentQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Document, error) {
	o := &Document{}

	queries.SetLimit(q.Query, 1)

	err := q.Bind(ctx, exec, o)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, sql.ErrNoRows
		}
		return nil, errors.Wrap(err, "repository: failed to execute a one query for documents")
	}

	if err := o.doAfterSelectHooks(ctx, exec); err != nil {
		return o, err
	}

	return o, nil
}

// All returns all Document records from the query.
func (q documentQuery) All(ctx context.Context, exec boil.ContextExecutor) (DocumentSlice, error) {
	var o []*Document

	err := q.Bind(ctx, exec, &o)
	if err != nil {
		return nil, errors.Wrap(err, "repository: failed to assign all query results to Document slice")
	}

	if len(documentAfterSelectHooks) != 0 {
		for _, obj := range o {
			if err := obj.doAfterSelectHooks(ctx, exec); err != nil {
				return o, err
			}
		}
	}

	return o, nil
}

// Count returns the count of all Document records in the query.
func (q documentQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	var count int64

	queries.SetSelect(q.Query, nil)
	queries.SetCount(q.Query)

	err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
	if err != nil {
		return 0, errors.Wrap(err, "repository: failed to count documents rows")
	}

	return count, nil
}

// Exists checks if the row exists in the table.
func (q documentQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
	var count int64

	queries.SetSelect(q.Query, nil)
	queries.SetCount(q.Query)
	queries.SetLimit(q.Query, 1)

	err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
	if err != nil {
		return false, errors.Wrap(err, "repository: failed to check if documents exists")
	}

	return count > 0, nil
}

// DocumentType pointed to by the foreign key.
func (o *Document) DocumentType(mods ...qm.QueryMod) documentTypeQuery {
	queryMods := []qm.QueryMod{
		qm.Where("[id] = ?", o.DocumentTypeID),
	}

	queryMods = append(queryMods, mods...)

	return DocumentTypes(queryMods...)
}

// Tags retrieves all the tag's Tags with an executor.
func (o *Document) Tags(mods ...qm.QueryMod) tagQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.InnerJoin("[dbo].[document_contexts] on [dbo].[tags].[id] = [dbo].[document_contexts].[tag_id]"),
		qm.Where("[dbo].[document_contexts].[document_id]=?", o.ID),
	)

	return Tags(queryMods...)
}

// SourceDocuments retrieves all the document's Documents with an executor via id column.
func (o *Document) SourceDocuments(mods ...qm.QueryMod) documentQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.InnerJoin("[dbo].[links] on [dbo].[documents].[id] = [dbo].[links].[source_id]"),
		qm.Where("[dbo].[links].[destination_id]=?", o.ID),
	)

	return Documents(queryMods...)
}

// DestinationDocuments retrieves all the document's Documents with an executor via id column.
func (o *Document) DestinationDocuments(mods ...qm.QueryMod) documentQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.InnerJoin("[dbo].[links] on [dbo].[documents].[id] = [dbo].[links].[destination_id]"),
		qm.Where("[dbo].[links].[source_id]=?", o.ID),
	)

	return Documents(queryMods...)
}

// LoadDocumentType allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for an N-1 relationship.
func (documentL) LoadDocumentType(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDocument interface{}, mods queries.Applicator) error {
	var slice []*Document
	var object *Document

	if singular {
		object = maybeDocument.(*Document)
	} else {
		slice = *maybeDocument.(*[]*Document)
	}

	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &documentR{}
		}
		if !queries.IsNil(object.DocumentTypeID) {
			args = append(args, object.DocumentTypeID)
		}

	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &documentR{}
			}

			for _, a := range args {
				if queries.Equal(a, obj.DocumentTypeID) {
					continue Outer
				}
			}

			if !queries.IsNil(obj.DocumentTypeID) {
				args = append(args, obj.DocumentTypeID)
			}

		}
	}

	if len(args) == 0 {
		return nil
	}

	query := NewQuery(
		qm.From(`dbo.document_types`),
		qm.WhereIn(`dbo.document_types.id in ?`, args...),
	)
	if mods != nil {
		mods.Apply(query)
	}

	results, err := query.QueryContext(ctx, e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load DocumentType")
	}

	var resultSlice []*DocumentType
	if err = queries.Bind(results, &resultSlice); err != nil {
		return errors.Wrap(err, "failed to bind eager loaded slice DocumentType")
	}

	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results of eager load for document_types")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for document_types")
	}

	if len(documentAfterSelectHooks) != 0 {
		for _, obj := range resultSlice {
			if err := obj.doAfterSelectHooks(ctx, e); err != nil {
				return err
			}
		}
	}

	if len(resultSlice) == 0 {
		return nil
	}

	if singular {
		foreign := resultSlice[0]
		object.R.DocumentType = foreign
		if foreign.R == nil {
			foreign.R = &documentTypeR{}
		}
		foreign.R.Documents = append(foreign.R.Documents, object)
		return nil
	}

	for _, local := range slice {
		for _, foreign := range resultSlice {
			if queries.Equal(local.DocumentTypeID, foreign.ID) {
				local.R.DocumentType = foreign
				if foreign.R == nil {
					foreign.R = &documentTypeR{}
				}
				foreign.R.Documents = append(foreign.R.Documents, local)
				break
			}
		}
	}

	return nil
}

// LoadTags allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (documentL) LoadTags(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDocument interface{}, mods queries.Applicator) error {
	var slice []*Document
	var object *Document

	if singular {
		object = maybeDocument.(*Document)
	} else {
		slice = *maybeDocument.(*[]*Document)
	}

	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &documentR{}
		}
		args = append(args, object.ID)
	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &documentR{}
			}

			for _, a := range args {
				if a == obj.ID {
					continue Outer
				}
			}

			args = append(args, obj.ID)
		}
	}

	if len(args) == 0 {
		return nil
	}

	query := NewQuery(
		qm.Select("[dbo].[tags].[id], [dbo].[tags].[tag], [dbo].[tags].[parent_tag], [dbo].[tags].[path], [dbo].[tags].[children], [a].[document_id]"),
		qm.From("[dbo].[tags]"),
		qm.InnerJoin("[dbo].[document_contexts] as [a] on [dbo].[tags].[id] = [a].[tag_id]"),
		qm.WhereIn("[a].[document_id] in ?", args...),
	)
	if mods != nil {
		mods.Apply(query)
	}

	results, err := query.QueryContext(ctx, e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load tags")
	}

	var resultSlice []*Tag

	var localJoinCols []int64
	for results.Next() {
		one := new(Tag)
		var localJoinCol int64

		err = results.Scan(&one.ID, &one.Tag, &one.ParentTag, &one.Path, &one.Children, &localJoinCol)
		if err != nil {
			return errors.Wrap(err, "failed to scan eager loaded results for tags")
		}
		if err = results.Err(); err != nil {
			return errors.Wrap(err, "failed to plebian-bind eager loaded slice tags")
		}

		resultSlice = append(resultSlice, one)
		localJoinCols = append(localJoinCols, localJoinCol)
	}

	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results in eager load on tags")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for tags")
	}

	if len(tagAfterSelectHooks) != 0 {
		for _, obj := range resultSlice {
			if err := obj.doAfterSelectHooks(ctx, e); err != nil {
				return err
			}
		}
	}
	if singular {
		object.R.Tags = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &tagR{}
			}
			foreign.R.Documents = append(foreign.R.Documents, object)
		}
		return nil
	}

	for i, foreign := range resultSlice {
		localJoinCol := localJoinCols[i]
		for _, local := range slice {
			if local.ID == localJoinCol {
				local.R.Tags = append(local.R.Tags, foreign)
				if foreign.R == nil {
					foreign.R = &tagR{}
				}
				foreign.R.Documents = append(foreign.R.Documents, local)
				break
			}
		}
	}

	return nil
}

// LoadSourceDocuments allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (documentL) LoadSourceDocuments(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDocument interface{}, mods queries.Applicator) error {
	var slice []*Document
	var object *Document

	if singular {
		object = maybeDocument.(*Document)
	} else {
		slice = *maybeDocument.(*[]*Document)
	}

	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &documentR{}
		}
		args = append(args, object.ID)
	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &documentR{}
			}

			for _, a := range args {
				if a == obj.ID {
					continue Outer
				}
			}

			args = append(args, obj.ID)
		}
	}

	if len(args) == 0 {
		return nil
	}

	query := NewQuery(
		qm.Select("[dbo].[documents].[id], [dbo].[documents].[path], [dbo].[documents].[document_type_id], [dbo].[documents].[created_at], [dbo].[documents].[updated_at], [dbo].[documents].[deleted_at], [a].[destination_id]"),
		qm.From("[dbo].[documents]"),
		qm.InnerJoin("[dbo].[links] as [a] on [dbo].[documents].[id] = [a].[source_id]"),
		qm.WhereIn("[a].[destination_id] in ?", args...),
	)
	if mods != nil {
		mods.Apply(query)
	}

	results, err := query.QueryContext(ctx, e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load documents")
	}

	var resultSlice []*Document

	var localJoinCols []int64
	for results.Next() {
		one := new(Document)
		var localJoinCol int64

		err = results.Scan(&one.ID, &one.Path, &one.DocumentTypeID, &one.CreatedAt, &one.UpdatedAt, &one.DeletedAt, &localJoinCol)
		if err != nil {
			return errors.Wrap(err, "failed to scan eager loaded results for documents")
		}
		if err = results.Err(); err != nil {
			return errors.Wrap(err, "failed to plebian-bind eager loaded slice documents")
		}

		resultSlice = append(resultSlice, one)
		localJoinCols = append(localJoinCols, localJoinCol)
	}

	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results in eager load on documents")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for documents")
	}

	if len(documentAfterSelectHooks) != 0 {
		for _, obj := range resultSlice {
			if err := obj.doAfterSelectHooks(ctx, e); err != nil {
				return err
			}
		}
	}
	if singular {
		object.R.SourceDocuments = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &documentR{}
			}
			foreign.R.DestinationDocuments = append(foreign.R.DestinationDocuments, object)
		}
		return nil
	}

	for i, foreign := range resultSlice {
		localJoinCol := localJoinCols[i]
		for _, local := range slice {
			if local.ID == localJoinCol {
				local.R.SourceDocuments = append(local.R.SourceDocuments, foreign)
				if foreign.R == nil {
					foreign.R = &documentR{}
				}
				foreign.R.DestinationDocuments = append(foreign.R.DestinationDocuments, local)
				break
			}
		}
	}

	return nil
}

// LoadDestinationDocuments allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (documentL) LoadDestinationDocuments(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDocument interface{}, mods queries.Applicator) error {
	var slice []*Document
	var object *Document

	if singular {
		object = maybeDocument.(*Document)
	} else {
		slice = *maybeDocument.(*[]*Document)
	}

	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &documentR{}
		}
		args = append(args, object.ID)
	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &documentR{}
			}

			for _, a := range args {
				if a == obj.ID {
					continue Outer
				}
			}

			args = append(args, obj.ID)
		}
	}

	if len(args) == 0 {
		return nil
	}

	query := NewQuery(
		qm.Select("[dbo].[documents].[id], [dbo].[documents].[path], [dbo].[documents].[document_type_id], [dbo].[documents].[created_at], [dbo].[documents].[updated_at], [dbo].[documents].[deleted_at], [a].[source_id]"),
		qm.From("[dbo].[documents]"),
		qm.InnerJoin("[dbo].[links] as [a] on [dbo].[documents].[id] = [a].[destination_id]"),
		qm.WhereIn("[a].[source_id] in ?", args...),
	)
	if mods != nil {
		mods.Apply(query)
	}

	results, err := query.QueryContext(ctx, e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load documents")
	}

	var resultSlice []*Document

	var localJoinCols []int64
	for results.Next() {
		one := new(Document)
		var localJoinCol int64

		err = results.Scan(&one.ID, &one.Path, &one.DocumentTypeID, &one.CreatedAt, &one.UpdatedAt, &one.DeletedAt, &localJoinCol)
		if err != nil {
			return errors.Wrap(err, "failed to scan eager loaded results for documents")
		}
		if err = results.Err(); err != nil {
			return errors.Wrap(err, "failed to plebian-bind eager loaded slice documents")
		}

		resultSlice = append(resultSlice, one)
		localJoinCols = append(localJoinCols, localJoinCol)
	}

	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results in eager load on documents")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for documents")
	}

	if len(documentAfterSelectHooks) != 0 {
		for _, obj := range resultSlice {
			if err := obj.doAfterSelectHooks(ctx, e); err != nil {
				return err
			}
		}
	}
	if singular {
		object.R.DestinationDocuments = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &documentR{}
			}
			foreign.R.SourceDocuments = append(foreign.R.SourceDocuments, object)
		}
		return nil
	}

	for i, foreign := range resultSlice {
		localJoinCol := localJoinCols[i]
		for _, local := range slice {
			if local.ID == localJoinCol {
				local.R.DestinationDocuments = append(local.R.DestinationDocuments, foreign)
				if foreign.R == nil {
					foreign.R = &documentR{}
				}
				foreign.R.SourceDocuments = append(foreign.R.SourceDocuments, local)
				break
			}
		}
	}

	return nil
}

// SetDocumentType of the document to the related item.
// Sets o.R.DocumentType to related.
// Adds o to related.R.Documents.
func (o *Document) SetDocumentType(ctx context.Context, exec boil.ContextExecutor, insert bool, related *DocumentType) error {
	var err error
	if insert {
		if err = related.Insert(ctx, exec, boil.Infer()); err != nil {
			return errors.Wrap(err, "failed to insert into foreign table")
		}
	}

	updateQuery := fmt.Sprintf(
		"UPDATE [dbo].[documents] SET %s WHERE %s",
		strmangle.SetParamNames("[", "]", 1, []string{"document_type_id"}),
		strmangle.WhereClause("[", "]", 2, documentPrimaryKeyColumns),
	)
	values := []interface{}{related.ID, o.ID}

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, updateQuery)
		fmt.Fprintln(writer, values)
	}
	if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil {
		return errors.Wrap(err, "failed to update local table")
	}

	queries.Assign(&o.DocumentTypeID, related.ID)
	if o.R == nil {
		o.R = &documentR{
			DocumentType: related,
		}
	} else {
		o.R.DocumentType = related
	}

	if related.R == nil {
		related.R = &documentTypeR{
			Documents: DocumentSlice{o},
		}
	} else {
		related.R.Documents = append(related.R.Documents, o)
	}

	return nil
}

// RemoveDocumentType relationship.
// Sets o.R.DocumentType to nil.
// Removes o from all passed in related items' relationships struct.
func (o *Document) RemoveDocumentType(ctx context.Context, exec boil.ContextExecutor, related *DocumentType) error {
	var err error

	queries.SetScanner(&o.DocumentTypeID, nil)
	if _, err = o.Update(ctx, exec, boil.Whitelist("document_type_id")); err != nil {
		return errors.Wrap(err, "failed to update local table")
	}

	if o.R != nil {
		o.R.DocumentType = nil
	}
	if related == nil || related.R == nil {
		return nil
	}

	for i, ri := range related.R.Documents {
		if queries.Equal(o.DocumentTypeID, ri.DocumentTypeID) {
			continue
		}

		ln := len(related.R.Documents)
		if ln > 1 && i < ln-1 {
			related.R.Documents[i] = related.R.Documents[ln-1]
		}
		related.R.Documents = related.R.Documents[:ln-1]
		break
	}
	return nil
}

// AddTags adds the given related objects to the existing relationships
// of the document, optionally inserting them as new records.
// Appends related to o.R.Tags.
// Sets related.R.Documents appropriately.
func (o *Document) AddTags(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Tag) error {
	var err error
	for _, rel := range related {
		if insert {
			if err = rel.Insert(ctx, exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		}
	}

	for _, rel := range related {
		query := "insert into [dbo].[document_contexts] ([document_id], [tag_id]) values ($1, $2)"
		values := []interface{}{o.ID, rel.ID}

		if boil.IsDebug(ctx) {
			writer := boil.DebugWriterFrom(ctx)
			fmt.Fprintln(writer, query)
			fmt.Fprintln(writer, values)
		}
		_, err = exec.ExecContext(ctx, query, values...)
		if err != nil {
			return errors.Wrap(err, "failed to insert into join table")
		}
	}
	if o.R == nil {
		o.R = &documentR{
			Tags: related,
		}
	} else {
		o.R.Tags = append(o.R.Tags, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &tagR{
				Documents: DocumentSlice{o},
			}
		} else {
			rel.R.Documents = append(rel.R.Documents, o)
		}
	}
	return nil
}

// SetTags removes all previously related items of the
// document replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Documents's Tags accordingly.
// Replaces o.R.Tags with related.
// Sets related.R.Documents's Tags accordingly.
func (o *Document) SetTags(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Tag) error {
	query := "delete from [dbo].[document_contexts] where [document_id] = $1"
	values := []interface{}{o.ID}
	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, query)
		fmt.Fprintln(writer, values)
	}
	_, err := exec.ExecContext(ctx, query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	removeTagsFromDocumentsSlice(o, related)
	if o.R != nil {
		o.R.Tags = nil
	}

	return o.AddTags(ctx, exec, insert, related...)
}

// RemoveTags relationships from objects passed in.
// Removes related items from R.Tags (uses pointer comparison, removal does not keep order)
// Sets related.R.Documents.
func (o *Document) RemoveTags(ctx context.Context, exec boil.ContextExecutor, related ...*Tag) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	query := fmt.Sprintf(
		"delete from [dbo].[document_contexts] where [document_id] = $1 and [tag_id] in (%s)",
		strmangle.Placeholders(dialect.UseIndexPlaceholders, len(related), 2, 1),
	)
	values := []interface{}{o.ID}
	for _, rel := range related {
		values = append(values, rel.ID)
	}

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, query)
		fmt.Fprintln(writer, values)
	}
	_, err = exec.ExecContext(ctx, query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}
	removeTagsFromDocumentsSlice(o, related)
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.Tags {
			if rel != ri {
				continue
			}

			ln := len(o.R.Tags)
			if ln > 1 && i < ln-1 {
				o.R.Tags[i] = o.R.Tags[ln-1]
			}
			o.R.Tags = o.R.Tags[:ln-1]
			break
		}
	}

	return nil
}

func removeTagsFromDocumentsSlice(o *Document, related []*Tag) {
	for _, rel := range related {
		if rel.R == nil {
			continue
		}
		for i, ri := range rel.R.Documents {
			if o.ID != ri.ID {
				continue
			}

			ln := len(rel.R.Documents)
			if ln > 1 && i < ln-1 {
				rel.R.Documents[i] = rel.R.Documents[ln-1]
			}
			rel.R.Documents = rel.R.Documents[:ln-1]
			break
		}
	}
}

// AddSourceDocuments adds the given related objects to the existing relationships
// of the document, optionally inserting them as new records.
// Appends related to o.R.SourceDocuments.
// Sets related.R.DestinationDocuments appropriately.
func (o *Document) AddSourceDocuments(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Document) error {
	var err error
	for _, rel := range related {
		if insert {
			if err = rel.Insert(ctx, exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		}
	}

	for _, rel := range related {
		query := "insert into [dbo].[links] ([destination_id], [source_id]) values ($1, $2)"
		values := []interface{}{o.ID, rel.ID}

		if boil.IsDebug(ctx) {
			writer := boil.DebugWriterFrom(ctx)
			fmt.Fprintln(writer, query)
			fmt.Fprintln(writer, values)
		}
		_, err = exec.ExecContext(ctx, query, values...)
		if err != nil {
			return errors.Wrap(err, "failed to insert into join table")
		}
	}
	if o.R == nil {
		o.R = &documentR{
			SourceDocuments: related,
		}
	} else {
		o.R.SourceDocuments = append(o.R.SourceDocuments, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &documentR{
				DestinationDocuments: DocumentSlice{o},
			}
		} else {
			rel.R.DestinationDocuments = append(rel.R.DestinationDocuments, o)
		}
	}
	return nil
}

// SetSourceDocuments removes all previously related items of the
// document replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.DestinationDocuments's SourceDocuments accordingly.
// Replaces o.R.SourceDocuments with related.
// Sets related.R.DestinationDocuments's SourceDocuments accordingly.
func (o *Document) SetSourceDocuments(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Document) error {
	query := "delete from [dbo].[links] where [destination_id] = $1"
	values := []interface{}{o.ID}
	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, query)
		fmt.Fprintln(writer, values)
	}
	_, err := exec.ExecContext(ctx, query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	removeSourceDocumentsFromDestinationDocumentsSlice(o, related)
	if o.R != nil {
		o.R.SourceDocuments = nil
	}

	return o.AddSourceDocuments(ctx, exec, insert, related...)
}

// RemoveSourceDocuments relationships from objects passed in.
// Removes related items from R.SourceDocuments (uses pointer comparison, removal does not keep order)
// Sets related.R.DestinationDocuments.
func (o *Document) RemoveSourceDocuments(ctx context.Context, exec boil.ContextExecutor, related ...*Document) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	query := fmt.Sprintf(
		"delete from [dbo].[links] where [destination_id] = $1 and [source_id] in (%s)",
		strmangle.Placeholders(dialect.UseIndexPlaceholders, len(related), 2, 1),
	)
	values := []interface{}{o.ID}
	for _, rel := range related {
		values = append(values, rel.ID)
	}

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, query)
		fmt.Fprintln(writer, values)
	}
	_, err = exec.ExecContext(ctx, query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}
	removeSourceDocumentsFromDestinationDocumentsSlice(o, related)
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.SourceDocuments {
			if rel != ri {
				continue
			}

			ln := len(o.R.SourceDocuments)
			if ln > 1 && i < ln-1 {
				o.R.SourceDocuments[i] = o.R.SourceDocuments[ln-1]
			}
			o.R.SourceDocuments = o.R.SourceDocuments[:ln-1]
			break
		}
	}

	return nil
}

func removeSourceDocumentsFromDestinationDocumentsSlice(o *Document, related []*Document) {
	for _, rel := range related {
		if rel.R == nil {
			continue
		}
		for i, ri := range rel.R.DestinationDocuments {
			if o.ID != ri.ID {
				continue
			}

			ln := len(rel.R.DestinationDocuments)
			if ln > 1 && i < ln-1 {
				rel.R.DestinationDocuments[i] = rel.R.DestinationDocuments[ln-1]
			}
			rel.R.DestinationDocuments = rel.R.DestinationDocuments[:ln-1]
			break
		}
	}
}

// AddDestinationDocuments adds the given related objects to the existing relationships
// of the document, optionally inserting them as new records.
// Appends related to o.R.DestinationDocuments.
// Sets related.R.SourceDocuments appropriately.
func (o *Document) AddDestinationDocuments(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Document) error {
	var err error
	for _, rel := range related {
		if insert {
			if err = rel.Insert(ctx, exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		}
	}

	for _, rel := range related {
		query := "insert into [dbo].[links] ([source_id], [destination_id]) values ($1, $2)"
		values := []interface{}{o.ID, rel.ID}

		if boil.IsDebug(ctx) {
			writer := boil.DebugWriterFrom(ctx)
			fmt.Fprintln(writer, query)
			fmt.Fprintln(writer, values)
		}
		_, err = exec.ExecContext(ctx, query, values...)
		if err != nil {
			return errors.Wrap(err, "failed to insert into join table")
		}
	}
	if o.R == nil {
		o.R = &documentR{
			DestinationDocuments: related,
		}
	} else {
		o.R.DestinationDocuments = append(o.R.DestinationDocuments, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &documentR{
				SourceDocuments: DocumentSlice{o},
			}
		} else {
			rel.R.SourceDocuments = append(rel.R.SourceDocuments, o)
		}
	}
	return nil
}

// SetDestinationDocuments removes all previously related items of the
// document replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.SourceDocuments's DestinationDocuments accordingly.
// Replaces o.R.DestinationDocuments with related.
// Sets related.R.SourceDocuments's DestinationDocuments accordingly.
func (o *Document) SetDestinationDocuments(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Document) error {
	query := "delete from [dbo].[links] where [source_id] = $1"
	values := []interface{}{o.ID}
	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, query)
		fmt.Fprintln(writer, values)
	}
	_, err := exec.ExecContext(ctx, query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	removeDestinationDocumentsFromSourceDocumentsSlice(o, related)
	if o.R != nil {
		o.R.DestinationDocuments = nil
	}

	return o.AddDestinationDocuments(ctx, exec, insert, related...)
}

// RemoveDestinationDocuments relationships from objects passed in.
// Removes related items from R.DestinationDocuments (uses pointer comparison, removal does not keep order)
// Sets related.R.SourceDocuments.
func (o *Document) RemoveDestinationDocuments(ctx context.Context, exec boil.ContextExecutor, related ...*Document) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	query := fmt.Sprintf(
		"delete from [dbo].[links] where [source_id] = $1 and [destination_id] in (%s)",
		strmangle.Placeholders(dialect.UseIndexPlaceholders, len(related), 2, 1),
	)
	values := []interface{}{o.ID}
	for _, rel := range related {
		values = append(values, rel.ID)
	}

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, query)
		fmt.Fprintln(writer, values)
	}
	_, err = exec.ExecContext(ctx, query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}
	removeDestinationDocumentsFromSourceDocumentsSlice(o, related)
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.DestinationDocuments {
			if rel != ri {
				continue
			}

			ln := len(o.R.DestinationDocuments)
			if ln > 1 && i < ln-1 {
				o.R.DestinationDocuments[i] = o.R.DestinationDocuments[ln-1]
			}
			o.R.DestinationDocuments = o.R.DestinationDocuments[:ln-1]
			break
		}
	}

	return nil
}

func removeDestinationDocumentsFromSourceDocumentsSlice(o *Document, related []*Document) {
	for _, rel := range related {
		if rel.R == nil {
			continue
		}
		for i, ri := range rel.R.SourceDocuments {
			if o.ID != ri.ID {
				continue
			}

			ln := len(rel.R.SourceDocuments)
			if ln > 1 && i < ln-1 {
				rel.R.SourceDocuments[i] = rel.R.SourceDocuments[ln-1]
			}
			rel.R.SourceDocuments = rel.R.SourceDocuments[:ln-1]
			break
		}
	}
}

// Documents retrieves all the records using an executor.
func Documents(mods ...qm.QueryMod) documentQuery {
	mods = append(mods, qm.From("[dbo].[documents]"))
	q := NewQuery(mods...)
	if len(queries.GetSelect(q)) == 0 {
		queries.SetSelect(q, []string{"[dbo].[documents].*"})
	}

	return documentQuery{q}
}

// FindDocument retrieves a single record by ID with an executor.
// If selectCols is empty Find will return all columns.
func FindDocument(ctx context.Context, exec boil.ContextExecutor, iD int64, selectCols ...string) (*Document, error) {
	documentObj := &Document{}

	sel := "*"
	if len(selectCols) > 0 {
		sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",")
	}
	query := fmt.Sprintf(
		"select %s from [dbo].[documents] where [id]=$1", sel,
	)

	q := queries.Raw(query, iD)

	err := q.Bind(ctx, exec, documentObj)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, sql.ErrNoRows
		}
		return nil, errors.Wrap(err, "repository: unable to select from documents")
	}

	if err = documentObj.doAfterSelectHooks(ctx, exec); err != nil {
		return documentObj, err
	}

	return documentObj, nil
}

// Insert a single record using an executor.
// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.
func (o *Document) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error {
	if o == nil {
		return errors.New("repository: no documents provided for insertion")
	}

	var err error

	if err := o.doBeforeInsertHooks(ctx, exec); err != nil {
		return err
	}

	nzDefaults := queries.NonZeroDefaultSet(documentColumnsWithDefault, o)

	key := makeCacheKey(columns, nzDefaults)
	documentInsertCacheMut.RLock()
	cache, cached := documentInsertCache[key]
	documentInsertCacheMut.RUnlock()

	if !cached {
		wl, returnColumns := columns.InsertColumnSet(
			documentAllColumns,
			documentColumnsWithDefault,
			documentColumnsWithoutDefault,
			nzDefaults,
		)

		cache.valueMapping, err = queries.BindMapping(documentType, documentMapping, wl)
		if err != nil {
			return err
		}
		cache.retMapping, err = queries.BindMapping(documentType, documentMapping, returnColumns)
		if err != nil {
			return err
		}
		if len(wl) != 0 {
			cache.query = fmt.Sprintf("INSERT INTO [dbo].[documents] ([%s]) %%sVALUES (%s)%%s", strings.Join(wl, "],["), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1))
		} else {
			cache.query = "INSERT INTO [dbo].[documents] %sDEFAULT VALUES%s"
		}

		var queryOutput, queryReturning string

		if len(cache.retMapping) != 0 {
			queryOutput = fmt.Sprintf("OUTPUT INSERTED.[%s] ", strings.Join(returnColumns, "],INSERTED.["))
		}

		cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning)
	}

	value := reflect.Indirect(reflect.ValueOf(o))
	vals := queries.ValuesFromMapping(value, cache.valueMapping)

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, cache.query)
		fmt.Fprintln(writer, vals)
	}

	if len(cache.retMapping) != 0 {
		err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...)
	} else {
		_, err = exec.ExecContext(ctx, cache.query, vals...)
	}

	if err != nil {
		return errors.Wrap(err, "repository: unable to insert into documents")
	}

	if !cached {
		documentInsertCacheMut.Lock()
		documentInsertCache[key] = cache
		documentInsertCacheMut.Unlock()
	}

	return o.doAfterInsertHooks(ctx, exec)
}

// Update uses an executor to update the Document.
// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates.
// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.
func (o *Document) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) {
	var err error
	if err = o.doBeforeUpdateHooks(ctx, exec); err != nil {
		return 0, err
	}
	key := makeCacheKey(columns, nil)
	documentUpdateCacheMut.RLock()
	cache, cached := documentUpdateCache[key]
	documentUpdateCacheMut.RUnlock()

	if !cached {
		wl := columns.UpdateColumnSet(
			documentAllColumns,
			documentPrimaryKeyColumns,
		)

		if !columns.IsWhitelist() {
			wl = strmangle.SetComplement(wl, []string{"created_at"})
		}
		if len(wl) == 0 {
			return 0, errors.New("repository: unable to update documents, could not build whitelist")
		}

		cache.query = fmt.Sprintf("UPDATE [dbo].[documents] SET %s WHERE %s",
			strmangle.SetParamNames("[", "]", 1, wl),
			strmangle.WhereClause("[", "]", len(wl)+1, documentPrimaryKeyColumns),
		)
		cache.valueMapping, err = queries.BindMapping(documentType, documentMapping, append(wl, documentPrimaryKeyColumns...))
		if err != nil {
			return 0, err
		}
	}

	values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping)

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, cache.query)
		fmt.Fprintln(writer, values)
	}
	var result sql.Result
	result, err = exec.ExecContext(ctx, cache.query, values...)
	if err != nil {
		return 0, errors.Wrap(err, "repository: unable to update documents row")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "repository: failed to get rows affected by update for documents")
	}

	if !cached {
		documentUpdateCacheMut.Lock()
		documentUpdateCache[key] = cache
		documentUpdateCacheMut.Unlock()
	}

	return rowsAff, o.doAfterUpdateHooks(ctx, exec)
}

// UpdateAll updates all rows with the specified column values.
func (q documentQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
	queries.SetUpdate(q.Query, cols)

	result, err := q.Query.ExecContext(ctx, exec)
	if err != nil {
		return 0, errors.Wrap(err, "repository: unable to update all for documents")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "repository: unable to retrieve rows affected for documents")
	}

	return rowsAff, nil
}

// UpdateAll updates all rows with the specified column values, using an executor.
func (o DocumentSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
	ln := int64(len(o))
	if ln == 0 {
		return 0, nil
	}

	if len(cols) == 0 {
		return 0, errors.New("repository: update all requires at least one column argument")
	}

	colNames := make([]string, len(cols))
	args := make([]interface{}, len(cols))

	i := 0
	for name, value := range cols {
		colNames[i] = name
		args[i] = value
		i++
	}

	// Append all of the primary key values for each column
	for _, obj := range o {
		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), documentPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := fmt.Sprintf("UPDATE [dbo].[documents] SET %s WHERE %s",
		strmangle.SetParamNames("[", "]", 1, colNames),
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, documentPrimaryKeyColumns, len(o)))

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, sql)
		fmt.Fprintln(writer, args...)
	}
	result, err := exec.ExecContext(ctx, sql, args...)
	if err != nil {
		return 0, errors.Wrap(err, "repository: unable to update all in document slice")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "repository: unable to retrieve rows affected all in update all document")
	}
	return rowsAff, nil
}

// Upsert attempts an insert using an executor, and does an update or ignore on conflict.
func (o *Document) Upsert(ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error {
	if o == nil {
		return errors.New("repository: no documents provided for upsert")
	}

	if err := o.doBeforeUpsertHooks(ctx, exec); err != nil {
		return err
	}

	nzDefaults := queries.NonZeroDefaultSet(documentColumnsWithDefault, o)

	// Build cache key in-line uglily - mysql vs psql problems
	buf := strmangle.GetBuffer()
	buf.WriteString(strconv.Itoa(updateColumns.Kind))
	for _, c := range updateColumns.Cols {
		buf.WriteString(c)
	}
	buf.WriteByte('.')
	buf.WriteString(strconv.Itoa(insertColumns.Kind))
	for _, c := range insertColumns.Cols {
		buf.WriteString(c)
	}
	buf.WriteByte('.')
	for _, c := range nzDefaults {
		buf.WriteString(c)
	}
	key := buf.String()
	strmangle.PutBuffer(buf)

	documentUpsertCacheMut.RLock()
	cache, cached := documentUpsertCache[key]
	documentUpsertCacheMut.RUnlock()

	var err error

	if !cached {
		insert, ret := insertColumns.InsertColumnSet(
			documentAllColumns,
			documentColumnsWithDefault,
			documentColumnsWithoutDefault,
			nzDefaults,
		)

		for i, v := range insert {
			if strmangle.ContainsAny(documentPrimaryKeyColumns, v) && strmangle.ContainsAny(documentColumnsWithDefault, v) {
				insert = append(insert[:i], insert[i+1:]...)
			}
		}
		if len(insert) == 0 {
			return errors.New("repository: unable to upsert documents, could not build insert column list")
		}

		update := updateColumns.UpdateColumnSet(
			documentAllColumns,
			documentPrimaryKeyColumns,
		)

		if !updateColumns.IsNone() && len(update) == 0 {
			return errors.New("repository: unable to upsert documents, could not build update column list")
		}

		cache.query = buildUpsertQueryMSSQL(dialect, "[dbo].[documents]", documentPrimaryKeyColumns, update, insert, ret)

		whitelist := make([]string, len(documentPrimaryKeyColumns))
		copy(whitelist, documentPrimaryKeyColumns)
		whitelist = append(whitelist, update...)
		whitelist = append(whitelist, insert...)

		cache.valueMapping, err = queries.BindMapping(documentType, documentMapping, whitelist)
		if err != nil {
			return err
		}
		if len(ret) != 0 {
			cache.retMapping, err = queries.BindMapping(documentType, documentMapping, ret)
			if err != nil {
				return err
			}
		}
	}

	value := reflect.Indirect(reflect.ValueOf(o))
	vals := queries.ValuesFromMapping(value, cache.valueMapping)
	var returns []interface{}
	if len(cache.retMapping) != 0 {
		returns = queries.PtrsFromMapping(value, cache.retMapping)
	}

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, cache.query)
		fmt.Fprintln(writer, vals)
	}
	if len(cache.retMapping) != 0 {
		err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...)
		if errors.Is(err, sql.ErrNoRows) {
			err = nil // MSSQL doesn't return anything when there's no update
		}
	} else {
		_, err = exec.ExecContext(ctx, cache.query, vals...)
	}
	if err != nil {
		return errors.Wrap(err, "repository: unable to upsert documents")
	}

	if !cached {
		documentUpsertCacheMut.Lock()
		documentUpsertCache[key] = cache
		documentUpsertCacheMut.Unlock()
	}

	return o.doAfterUpsertHooks(ctx, exec)
}

// Delete deletes a single Document record with an executor.
// Delete will match against the primary key column to find the record to delete.
func (o *Document) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	if o == nil {
		return 0, errors.New("repository: no Document provided for delete")
	}

	if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
		return 0, err
	}

	args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), documentPrimaryKeyMapping)
	sql := "DELETE FROM [dbo].[documents] WHERE [id]=$1"

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, sql)
		fmt.Fprintln(writer, args...)
	}
	result, err := exec.ExecContext(ctx, sql, args...)
	if err != nil {
		return 0, errors.Wrap(err, "repository: unable to delete from documents")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "repository: failed to get rows affected by delete for documents")
	}

	if err := o.doAfterDeleteHooks(ctx, exec); err != nil {
		return 0, err
	}

	return rowsAff, nil
}

// DeleteAll deletes all matching rows.
func (q documentQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	if q.Query == nil {
		return 0, errors.New("repository: no documentQuery provided for delete all")
	}

	queries.SetDelete(q.Query)

	result, err := q.Query.ExecContext(ctx, exec)
	if err != nil {
		return 0, errors.Wrap(err, "repository: unable to delete all from documents")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "repository: failed to get rows affected by deleteall for documents")
	}

	return rowsAff, nil
}

// DeleteAll deletes all rows in the slice, using an executor.
func (o DocumentSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	if len(o) == 0 {
		return 0, nil
	}

	if len(documentBeforeDeleteHooks) != 0 {
		for _, obj := range o {
			if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
				return 0, err
			}
		}
	}

	var args []interface{}
	for _, obj := range o {
		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), documentPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := "DELETE FROM [dbo].[documents] WHERE " +
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, documentPrimaryKeyColumns, len(o))

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, sql)
		fmt.Fprintln(writer, args)
	}
	result, err := exec.ExecContext(ctx, sql, args...)
	if err != nil {
		return 0, errors.Wrap(err, "repository: unable to delete all from document slice")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "repository: failed to get rows affected by deleteall for documents")
	}

	if len(documentAfterDeleteHooks) != 0 {
		for _, obj := range o {
			if err := obj.doAfterDeleteHooks(ctx, exec); err != nil {
				return 0, err
			}
		}
	}

	return rowsAff, nil
}

// Reload refetches the object from the database
// using the primary keys with an executor.
func (o *Document) Reload(ctx context.Context, exec boil.ContextExecutor) error {
	ret, err := FindDocument(ctx, exec, o.ID)
	if err != nil {
		return err
	}

	*o = *ret
	return nil
}

// ReloadAll refetches every row with matching primary key column values
// and overwrites the original object slice with the newly updated slice.
func (o *DocumentSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error {
	if o == nil || len(*o) == 0 {
		return nil
	}

	slice := DocumentSlice{}
	var args []interface{}
	for _, obj := range *o {
		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), documentPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := "SELECT [dbo].[documents].* FROM [dbo].[documents] WHERE " +
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, documentPrimaryKeyColumns, len(*o))

	q := queries.Raw(sql, args...)

	err := q.Bind(ctx, exec, &slice)
	if err != nil {
		return errors.Wrap(err, "repository: unable to reload all in DocumentSlice")
	}

	*o = slice

	return nil
}

// DocumentExists checks if the Document row exists.
func DocumentExists(ctx context.Context, exec boil.ContextExecutor, iD int64) (bool, error) {
	var exists bool
	sql := "select case when exists(select top(1) 1 from [dbo].[documents] where [id]=$1) then 1 else 0 end"

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, sql)
		fmt.Fprintln(writer, iD)
	}
	row := exec.QueryRowContext(ctx, sql, iD)

	err := row.Scan(&exists)
	if err != nil {
		return false, errors.Wrap(err, "repository: unable to check if documents exists")
	}

	return exists, nil
}