func (q transactionAddressQuery) OneGP() *TransactionAddress {
	o, err := q.One(boil.GetDB())
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
OneGP returns a single transactionAddress record from the query using the global executor, and panics on error.
package model
import (
	"database/sql"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"sync"
	"time"
	"github.com/pkg/errors"
	"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 TransactionAddress struct {
	TransactionID uint64  `boil:"transaction_id" json:"transaction_id" toml:"transaction_id" yaml:"transaction_id"`
	AddressID     uint64  `boil:"address_id" json:"address_id" toml:"address_id" yaml:"address_id"`
	DebitAmount   float64 `boil:"debit_amount" json:"debit_amount" toml:"debit_amount" yaml:"debit_amount"`
	CreditAmount  float64 `boil:"credit_amount" json:"credit_amount" toml:"credit_amount" yaml:"credit_amount"`
	R *transactionAddressR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L transactionAddressL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}
var TransactionAddressColumns = struct {
	TransactionID string
	AddressID     string
	DebitAmount   string
	CreditAmount  string
}{
	TransactionID: "transaction_id",
	AddressID:     "address_id",
	DebitAmount:   "debit_amount",
	CreditAmount:  "credit_amount",
}
var TransactionAddressWhere = struct {
	TransactionID whereHelperuint64
	AddressID     whereHelperuint64
	DebitAmount   whereHelperfloat64
	CreditAmount  whereHelperfloat64
}{
	TransactionID: whereHelperuint64{field: "`transaction_address`.`transaction_id`"},
	AddressID:     whereHelperuint64{field: "`transaction_address`.`address_id`"},
	DebitAmount:   whereHelperfloat64{field: "`transaction_address`.`debit_amount`"},
	CreditAmount:  whereHelperfloat64{field: "`transaction_address`.`credit_amount`"},
}
var TransactionAddressRels = struct {
	Transaction string
	Address     string
}{
	Transaction: "Transaction",
	Address:     "Address",
}
type transactionAddressR struct {
	Transaction *Transaction
	Address     *Address
}
func (*transactionAddressR) NewStruct() *transactionAddressR {
	return &transactionAddressR{}
}
type transactionAddressL struct{}
var (
	transactionAddressAllColumns            = []string{"transaction_id", "address_id", "debit_amount", "credit_amount"}
	transactionAddressColumnsWithoutDefault = []string{"transaction_id", "address_id"}
	transactionAddressColumnsWithDefault    = []string{"debit_amount", "credit_amount"}
	transactionAddressPrimaryKeyColumns     = []string{"transaction_id", "address_id"}
)
type (
	TransactionAddressSlice []*TransactionAddress
	transactionAddressQuery struct {
		*queries.Query
	}
)
var (
	transactionAddressType                 = reflect.TypeOf(&TransactionAddress{})
	transactionAddressMapping              = queries.MakeStructMapping(transactionAddressType)
	transactionAddressPrimaryKeyMapping, _ = queries.BindMapping(transactionAddressType, transactionAddressMapping, transactionAddressPrimaryKeyColumns)
	transactionAddressInsertCacheMut       sync.RWMutex
	transactionAddressInsertCache          = make(map[string]insertCache)
	transactionAddressUpdateCacheMut       sync.RWMutex
	transactionAddressUpdateCache          = make(map[string]updateCache)
	transactionAddressUpsertCacheMut       sync.RWMutex
	transactionAddressUpsertCache          = make(map[string]insertCache)
)
var (
	_ = time.Second
	_ = qmhelper.Where
)
func (q transactionAddressQuery) OneG() (*TransactionAddress, error) {
	return q.One(boil.GetDB())
}