func (transactionL) LoadTransactionByHashPurchases(e boil.Executor, singular bool, maybeTransaction interface{}, mods queries.Applicator) error {
	var slice []*Transaction
	var object *Transaction
	if singular {
		object = maybeTransaction.(*Transaction)
	} else {
		slice = *maybeTransaction.(*[]*Transaction)
	}
	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &transactionR{}
		}
		args = append(args, object.Hash)
	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &transactionR{}
			}
			for _, a := range args {
				if queries.Equal(a, obj.Hash) {
					continue Outer
				}
			}
			args = append(args, obj.Hash)
		}
	}
	if len(args) == 0 {
		return nil
	}
	query := NewQuery(qm.From(`purchase`), qm.WhereIn(`transaction_by_hash_id in ?`, args...))
	if mods != nil {
		mods.Apply(query)
	}
	results, err := query.Query(e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load purchase")
	}
	var resultSlice []*Purchase
	if err = queries.Bind(results, &resultSlice); err != nil {
		return errors.Wrap(err, "failed to bind eager loaded slice purchase")
	}
	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results in eager load on purchase")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for purchase")
	}
	if singular {
		object.R.TransactionByHashPurchases = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &purchaseR{}
			}
			foreign.R.TransactionByHash = object
		}
		return nil
	}
	for _, foreign := range resultSlice {
		for _, local := range slice {
			if queries.Equal(local.Hash, foreign.TransactionByHashID) {
				local.R.TransactionByHashPurchases = append(local.R.TransactionByHashPurchases, foreign)
				if foreign.R == nil {
					foreign.R = &purchaseR{}
				}
				foreign.R.TransactionByHash = local
				break
			}
		}
	}
	return nil
}
LoadTransactionByHashPurchases allows an eager lookup of values, cached into the
loaded structs of the objects. This is for a 1-M or N-M relationship.
package model
import (
	"database/sql"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"sync"
	"time"
	"github.com/pkg/errors"
	"github.com/volatiletech/null"
	"github.com/volatiletech/sqlboiler/boil"
	"github.com/volatiletech/sqlboiler/queries"
	"github.com/volatiletech/sqlboiler/queries/qm"
	"github.com/volatiletech/sqlboiler/queries/qmhelper"
	"github.com/volatiletech/sqlboiler/strmangle"
)
type Transaction struct {
	ID              uint64      `boil:"id" json:"id" toml:"id" yaml:"id"`
	BlockHashID     null.String `boil:"block_hash_id" json:"block_hash_id,omitempty" toml:"block_hash_id" yaml:"block_hash_id,omitempty"`
	InputCount      uint        `boil:"input_count" json:"input_count" toml:"input_count" yaml:"input_count"`
	OutputCount     uint        `boil:"output_count" json:"output_count" toml:"output_count" yaml:"output_count"`
	Fee             float64     `boil:"fee" json:"fee" toml:"fee" yaml:"fee"`
	TransactionTime null.Uint64 `boil:"transaction_time" json:"transaction_time,omitempty" toml:"transaction_time" yaml:"transaction_time,omitempty"`
	TransactionSize uint64      `boil:"transaction_size" json:"transaction_size" toml:"transaction_size" yaml:"transaction_size"`
	Hash            string      `boil:"hash" json:"hash" toml:"hash" yaml:"hash"`
	Version         int         `boil:"version" json:"version" toml:"version" yaml:"version"`
	LockTime        uint        `boil:"lock_time" json:"lock_time" toml:"lock_time" yaml:"lock_time"`
	Raw             null.String `boil:"raw" json:"raw,omitempty" toml:"raw" yaml:"raw,omitempty"`
	CreatedAt       time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
	ModifiedAt      time.Time   `boil:"modified_at" json:"modified_at" toml:"modified_at" yaml:"modified_at"`
	CreatedTime     time.Time   `boil:"created_time" json:"created_time" toml:"created_time" yaml:"created_time"`
	Value           float64     `boil:"value" json:"value" toml:"value" yaml:"value"`
	R *transactionR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L transactionL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}
var TransactionColumns = struct {
	ID              string
	BlockHashID     string
	InputCount      string
	OutputCount     string
	Fee             string
	TransactionTime string
	TransactionSize string
	Hash            string
	Version         string
	LockTime        string
	Raw             string
	CreatedAt       string
	ModifiedAt      string
	CreatedTime     string
	Value           string
}{
	ID:              "id",
	BlockHashID:     "block_hash_id",
	InputCount:      "input_count",
	OutputCount:     "output_count",
	Fee:             "fee",
	TransactionTime: "transaction_time",
	TransactionSize: "transaction_size",
	Hash:            "hash",
	Version:         "version",
	LockTime:        "lock_time",
	Raw:             "raw",
	CreatedAt:       "created_at",
	ModifiedAt:      "modified_at",
	CreatedTime:     "created_time",
	Value:           "value",
}
var TransactionWhere = struct {
	ID              whereHelperuint64
	BlockHashID     whereHelpernull_String
	InputCount      whereHelperuint
	OutputCount     whereHelperuint
	Fee             whereHelperfloat64
	TransactionTime whereHelpernull_Uint64
	TransactionSize whereHelperuint64
	Hash            whereHelperstring
	Version         whereHelperint
	LockTime        whereHelperuint
	Raw             whereHelpernull_String
	CreatedAt       whereHelpertime_Time
	ModifiedAt      whereHelpertime_Time
	CreatedTime     whereHelpertime_Time
	Value           whereHelperfloat64
}{
	ID:              whereHelperuint64{field: "`transaction`.`id`"},
	BlockHashID:     whereHelpernull_String{field: "`transaction`.`block_hash_id`"},
	InputCount:      whereHelperuint{field: "`transaction`.`input_count`"},
	OutputCount:     whereHelperuint{field: "`transaction`.`output_count`"},
	Fee:             whereHelperfloat64{field: "`transaction`.`fee`"},
	TransactionTime: whereHelpernull_Uint64{field: "`transaction`.`transaction_time`"},
	TransactionSize: whereHelperuint64{field: "`transaction`.`transaction_size`"},
	Hash:            whereHelperstring{field: "`transaction`.`hash`"},
	Version:         whereHelperint{field: "`transaction`.`version`"},
	LockTime:        whereHelperuint{field: "`transaction`.`lock_time`"},
	Raw:             whereHelpernull_String{field: "`transaction`.`raw`"},
	CreatedAt:       whereHelpertime_Time{field: "`transaction`.`created_at`"},
	ModifiedAt:      whereHelpertime_Time{field: "`transaction`.`modified_at`"},
	CreatedTime:     whereHelpertime_Time{field: "`transaction`.`created_time`"},
	Value:           whereHelperfloat64{field: "`transaction`.`value`"},
}
var TransactionRels = struct {
	BlockHash                  string
	TransactionHashClaims      string
	Inputs                     string
	Outputs                    string
	TransactionByHashPurchases string
	TransactionHashSupports    string
	TransactionAddresses       string
}{
	BlockHash:                  "BlockHash",
	TransactionHashClaims:      "TransactionHashClaims",
	Inputs:                     "Inputs",
	Outputs:                    "Outputs",
	TransactionByHashPurchases: "TransactionByHashPurchases",
	TransactionHashSupports:    "TransactionHashSupports",
	TransactionAddresses:       "TransactionAddresses",
}
type transactionR struct {
	BlockHash                  *Block
	TransactionHashClaims      ClaimSlice
	Inputs                     InputSlice
	Outputs                    OutputSlice
	TransactionByHashPurchases PurchaseSlice
	TransactionHashSupports    SupportSlice
	TransactionAddresses       TransactionAddressSlice
}
func (*transactionR) NewStruct() *transactionR {
	return &transactionR{}
}
type transactionL struct{}
var (
	transactionAllColumns            = []string{"id", "block_hash_id", "input_count", "output_count", "fee", "transaction_time", "transaction_size", "hash", "version", "lock_time", "raw", "created_at", "modified_at", "created_time", "value"}
	transactionColumnsWithoutDefault = []string{"block_hash_id", "input_count", "output_count", "transaction_time", "transaction_size", "hash", "version", "lock_time", "raw"}
	transactionColumnsWithDefault    = []string{"id", "fee", "created_at", "modified_at", "created_time", "value"}
	transactionPrimaryKeyColumns     = []string{"id"}
)
type (
	TransactionSlice []*Transaction
	transactionQuery struct {
		*queries.Query
	}
)
var (
	transactionType                 = reflect.TypeOf(&Transaction{})
	transactionMapping              = queries.MakeStructMapping(transactionType)
	transactionPrimaryKeyMapping, _ = queries.BindMapping(transactionType, transactionMapping, transactionPrimaryKeyColumns)
	transactionInsertCacheMut       sync.RWMutex
	transactionInsertCache          = make(map[string]insertCache)
	transactionUpdateCacheMut       sync.RWMutex
	transactionUpdateCache          = make(map[string]updateCache)
	transactionUpsertCacheMut       sync.RWMutex
	transactionUpsertCache          = make(map[string]insertCache)
)
var (
	_ = time.Second
	_ = qmhelper.Where
)
func (q transactionQuery) OneG() (*Transaction, error) {
	return q.One(boil.GetDB())
}
func (q transactionQuery) OneGP() *Transaction {
	o, err := q.One(boil.GetDB())
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q transactionQuery) OneP(exec boil.Executor) *Transaction {
	o, err := q.One(exec)
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q transactionQuery) One(exec boil.Executor) (*Transaction, error) {
	o := &Transaction{}
	queries.SetLimit(q.Query, 1)
	err := q.Bind(nil, exec, o)
	if err != nil {
		if errors.Cause(err) == sql.ErrNoRows {
			return nil, sql.ErrNoRows
		}
		return nil, errors.Wrap(err, "model: failed to execute a one query for transaction")
	}
	return o, nil
}
func (q transactionQuery) AllG() (TransactionSlice, error) {
	return q.All(boil.GetDB())
}
func (q transactionQuery) AllGP() TransactionSlice {
	o, err := q.All(boil.GetDB())
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q transactionQuery) AllP(exec boil.Executor) TransactionSlice {
	o, err := q.All(exec)
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q transactionQuery) All(exec boil.Executor) (TransactionSlice, error) {
	var o []*Transaction
	err := q.Bind(nil, exec, &o)
	if err != nil {
		return nil, errors.Wrap(err, "model: failed to assign all query results to Transaction slice")
	}
	return o, nil
}
func (q transactionQuery) CountG() (int64, error) {
	return q.Count(boil.GetDB())
}
func (q transactionQuery) CountGP() int64 {
	c, err := q.Count(boil.GetDB())
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return c
}
func (q transactionQuery) CountP(exec boil.Executor) int64 {
	c, err := q.Count(exec)
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return c
}
func (q transactionQuery) Count(exec boil.Executor) (int64, error) {
	var count int64
	queries.SetSelect(q.Query, nil)
	queries.SetCount(q.Query)
	err := q.Query.QueryRow(exec).Scan(&count)
	if err != nil {
		return 0, errors.Wrap(err, "model: failed to count transaction rows")
	}
	return count, nil
}
func (q transactionQuery) ExistsG() (bool, error) {
	return q.Exists(boil.GetDB())
}
func (q transactionQuery) ExistsGP() bool {
	e, err := q.Exists(boil.GetDB())
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return e
}
func (q transactionQuery) ExistsP(exec boil.Executor) bool {
	e, err := q.Exists(exec)
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return e
}
func (q transactionQuery) Exists(exec boil.Executor) (bool, error) {
	var count int64
	queries.SetSelect(q.Query, nil)
	queries.SetCount(q.Query)
	queries.SetLimit(q.Query, 1)
	err := q.Query.QueryRow(exec).Scan(&count)
	if err != nil {
		return false, errors.Wrap(err, "model: failed to check if transaction exists")
	}
	return count > 0, nil
}
func (o *Transaction) BlockHash(mods ...qm.QueryMod) blockQuery {
	queryMods := []qm.QueryMod{
		qm.Where("hash=?", o.BlockHashID),
	}
	queryMods = append(queryMods, mods...)
	query := Blocks(queryMods...)
	queries.SetFrom(query.Query, "`block`")
	return query
}
func (o *Transaction) TransactionHashClaims(mods ...qm.QueryMod) claimQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}
	queryMods = append(queryMods,
		qm.Where("`claim`.`transaction_hash_id`=?", o.Hash),
	)
	query := Claims(queryMods...)
	queries.SetFrom(query.Query, "`claim`")
	if len(queries.GetSelect(query.Query)) == 0 {
		queries.SetSelect(query.Query, []string{"`claim`.*"})
	}
	return query
}
func (o *Transaction) Inputs(mods ...qm.QueryMod) inputQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}
	queryMods = append(queryMods,
		qm.Where("`input`.`transaction_id`=?", o.ID),
	)
	query := Inputs(queryMods...)
	queries.SetFrom(query.Query, "`input`")
	if len(queries.GetSelect(query.Query)) == 0 {
		queries.SetSelect(query.Query, []string{"`input`.*"})
	}
	return query
}
func (o *Transaction) Outputs(mods ...qm.QueryMod) outputQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}
	queryMods = append(queryMods,
		qm.Where("`output`.`transaction_id`=?", o.ID),
	)
	query := Outputs(queryMods...)
	queries.SetFrom(query.Query, "`output`")
	if len(queries.GetSelect(query.Query)) == 0 {
		queries.SetSelect(query.Query, []string{"`output`.*"})
	}
	return query
}
func (o *Transaction) TransactionByHashPurchases(mods ...qm.QueryMod) purchaseQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}
	queryMods = append(queryMods,
		qm.Where("`purchase`.`transaction_by_hash_id`=?", o.Hash),
	)
	query := Purchases(queryMods...)
	queries.SetFrom(query.Query, "`purchase`")
	if len(queries.GetSelect(query.Query)) == 0 {
		queries.SetSelect(query.Query, []string{"`purchase`.*"})
	}
	return query
}
func (o *Transaction) TransactionHashSupports(mods ...qm.QueryMod) supportQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}
	queryMods = append(queryMods,
		qm.Where("`support`.`transaction_hash_id`=?", o.Hash),
	)
	query := Supports(queryMods...)
	queries.SetFrom(query.Query, "`support`")
	if len(queries.GetSelect(query.Query)) == 0 {
		queries.SetSelect(query.Query, []string{"`support`.*"})
	}
	return query
}
func (o *Transaction) TransactionAddresses(mods ...qm.QueryMod) transactionAddressQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}
	queryMods = append(queryMods,
		qm.Where("`transaction_address`.`transaction_id`=?", o.ID),
	)
	query := TransactionAddresses(queryMods...)
	queries.SetFrom(query.Query, "`transaction_address`")
	if len(queries.GetSelect(query.Query)) == 0 {
		queries.SetSelect(query.Query, []string{"`transaction_address`.*"})
	}
	return query
}
func (transactionL) LoadBlockHash(e boil.Executor, singular bool, maybeTransaction interface{}, mods queries.Applicator) error {
	var slice []*Transaction
	var object *Transaction
	if singular {
		object = maybeTransaction.(*Transaction)
	} else {
		slice = *maybeTransaction.(*[]*Transaction)
	}
	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &transactionR{}
		}
		if !queries.IsNil(object.BlockHashID) {
			args = append(args, object.BlockHashID)
		}
	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &transactionR{}
			}
			for _, a := range args {
				if queries.Equal(a, obj.BlockHashID) {
					continue Outer
				}
			}
			if !queries.IsNil(obj.BlockHashID) {
				args = append(args, obj.BlockHashID)
			}
		}
	}
	if len(args) == 0 {
		return nil
	}
	query := NewQuery(qm.From(`block`), qm.WhereIn(`hash in ?`, args...))
	if mods != nil {
		mods.Apply(query)
	}
	results, err := query.Query(e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load Block")
	}
	var resultSlice []*Block
	if err = queries.Bind(results, &resultSlice); err != nil {
		return errors.Wrap(err, "failed to bind eager loaded slice Block")
	}
	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results of eager load for block")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for block")
	}
	if len(resultSlice) == 0 {
		return nil
	}
	if singular {
		foreign := resultSlice[0]
		object.R.BlockHash = foreign
		if foreign.R == nil {
			foreign.R = &blockR{}
		}
		foreign.R.BlockHashTransactions = append(foreign.R.BlockHashTransactions, object)
		return nil
	}
	for _, local := range slice {
		for _, foreign := range resultSlice {
			if queries.Equal(local.BlockHashID, foreign.Hash) {
				local.R.BlockHash = foreign
				if foreign.R == nil {
					foreign.R = &blockR{}
				}
				foreign.R.BlockHashTransactions = append(foreign.R.BlockHashTransactions, local)
				break
			}
		}
	}
	return nil
}
func (transactionL) LoadTransactionHashClaims(e boil.Executor, singular bool, maybeTransaction interface{}, mods queries.Applicator) error {
	var slice []*Transaction
	var object *Transaction
	if singular {
		object = maybeTransaction.(*Transaction)
	} else {
		slice = *maybeTransaction.(*[]*Transaction)
	}
	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &transactionR{}
		}
		args = append(args, object.Hash)
	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &transactionR{}
			}
			for _, a := range args {
				if queries.Equal(a, obj.Hash) {
					continue Outer
				}
			}
			args = append(args, obj.Hash)
		}
	}
	if len(args) == 0 {
		return nil
	}
	query := NewQuery(qm.From(`claim`), qm.WhereIn(`transaction_hash_id in ?`, args...))
	if mods != nil {
		mods.Apply(query)
	}
	results, err := query.Query(e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load claim")
	}
	var resultSlice []*Claim
	if err = queries.Bind(results, &resultSlice); err != nil {
		return errors.Wrap(err, "failed to bind eager loaded slice claim")
	}
	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results in eager load on claim")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for claim")
	}
	if singular {
		object.R.TransactionHashClaims = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &claimR{}
			}
			foreign.R.TransactionHash = object
		}
		return nil
	}
	for _, foreign := range resultSlice {
		for _, local := range slice {
			if queries.Equal(local.Hash, foreign.TransactionHashID) {
				local.R.TransactionHashClaims = append(local.R.TransactionHashClaims, foreign)
				if foreign.R == nil {
					foreign.R = &claimR{}
				}
				foreign.R.TransactionHash = local
				break
			}
		}
	}
	return nil
}
func (transactionL) LoadInputs(e boil.Executor, singular bool, maybeTransaction interface{}, mods queries.Applicator) error {
	var slice []*Transaction
	var object *Transaction
	if singular {
		object = maybeTransaction.(*Transaction)
	} else {
		slice = *maybeTransaction.(*[]*Transaction)
	}
	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &transactionR{}
		}
		args = append(args, object.ID)
	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &transactionR{}
			}
			for _, a := range args {
				if a == obj.ID {
					continue Outer
				}
			}
			args = append(args, obj.ID)
		}
	}
	if len(args) == 0 {
		return nil
	}
	query := NewQuery(qm.From(`input`), qm.WhereIn(`transaction_id in ?`, args...))
	if mods != nil {
		mods.Apply(query)
	}
	results, err := query.Query(e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load input")
	}
	var resultSlice []*Input
	if err = queries.Bind(results, &resultSlice); err != nil {
		return errors.Wrap(err, "failed to bind eager loaded slice input")
	}
	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results in eager load on input")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for input")
	}
	if singular {
		object.R.Inputs = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &inputR{}
			}
			foreign.R.Transaction = object
		}
		return nil
	}
	for _, foreign := range resultSlice {
		for _, local := range slice {
			if local.ID == foreign.TransactionID {
				local.R.Inputs = append(local.R.Inputs, foreign)
				if foreign.R == nil {
					foreign.R = &inputR{}
				}
				foreign.R.Transaction = local
				break
			}
		}
	}
	return nil
}
func (transactionL) LoadOutputs(e boil.Executor, singular bool, maybeTransaction interface{}, mods queries.Applicator) error {
	var slice []*Transaction
	var object *Transaction
	if singular {
		object = maybeTransaction.(*Transaction)
	} else {
		slice = *maybeTransaction.(*[]*Transaction)
	}
	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &transactionR{}
		}
		args = append(args, object.ID)
	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &transactionR{}
			}
			for _, a := range args {
				if a == obj.ID {
					continue Outer
				}
			}
			args = append(args, obj.ID)
		}
	}
	if len(args) == 0 {
		return nil
	}
	query := NewQuery(qm.From(`output`), qm.WhereIn(`transaction_id in ?`, args...))
	if mods != nil {
		mods.Apply(query)
	}
	results, err := query.Query(e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load output")
	}
	var resultSlice []*Output
	if err = queries.Bind(results, &resultSlice); err != nil {
		return errors.Wrap(err, "failed to bind eager loaded slice output")
	}
	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results in eager load on output")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for output")
	}
	if singular {
		object.R.Outputs = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &outputR{}
			}
			foreign.R.Transaction = object
		}
		return nil
	}
	for _, foreign := range resultSlice {
		for _, local := range slice {
			if local.ID == foreign.TransactionID {
				local.R.Outputs = append(local.R.Outputs, foreign)
				if foreign.R == nil {
					foreign.R = &outputR{}
				}
				foreign.R.Transaction = local
				break
			}
		}
	}
	return nil
}