func (q inputQuery) CountG() (int64, error) {
	return q.Count(boil.GetDB())
}
CountG returns the count of all Input records in the query, and panics on error.
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 Input struct {
	ID                  uint64       `boil:"id" json:"id" toml:"id" yaml:"id"`
	TransactionID       uint64       `boil:"transaction_id" json:"transaction_id" toml:"transaction_id" yaml:"transaction_id"`
	TransactionHash     string       `boil:"transaction_hash" json:"transaction_hash" toml:"transaction_hash" yaml:"transaction_hash"`
	InputAddressID      null.Uint64  `boil:"input_address_id" json:"input_address_id,omitempty" toml:"input_address_id" yaml:"input_address_id,omitempty"`
	IsCoinbase          bool         `boil:"is_coinbase" json:"is_coinbase" toml:"is_coinbase" yaml:"is_coinbase"`
	Coinbase            null.String  `boil:"coinbase" json:"coinbase,omitempty" toml:"coinbase" yaml:"coinbase,omitempty"`
	PrevoutHash         null.String  `boil:"prevout_hash" json:"prevout_hash,omitempty" toml:"prevout_hash" yaml:"prevout_hash,omitempty"`
	PrevoutN            null.Uint    `boil:"prevout_n" json:"prevout_n,omitempty" toml:"prevout_n" yaml:"prevout_n,omitempty"`
	PrevoutSpendUpdated bool         `boil:"prevout_spend_updated" json:"prevout_spend_updated" toml:"prevout_spend_updated" yaml:"prevout_spend_updated"`
	Sequence            uint         `boil:"sequence" json:"sequence" toml:"sequence" yaml:"sequence"`
	Value               null.Float64 `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`
	ScriptSigAsm        null.String  `boil:"script_sig_asm" json:"script_sig_asm,omitempty" toml:"script_sig_asm" yaml:"script_sig_asm,omitempty"`
	ScriptSigHex        null.String  `boil:"script_sig_hex" json:"script_sig_hex,omitempty" toml:"script_sig_hex" yaml:"script_sig_hex,omitempty"`
	Created             time.Time    `boil:"created" json:"created" toml:"created" yaml:"created"`
	Modified            time.Time    `boil:"modified" json:"modified" toml:"modified" yaml:"modified"`
	Vin                 null.Uint    `boil:"vin" json:"vin,omitempty" toml:"vin" yaml:"vin,omitempty"`
	Witness             null.String  `boil:"witness" json:"witness,omitempty" toml:"witness" yaml:"witness,omitempty"`
	R *inputR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L inputL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}
var InputColumns = struct {
	ID                  string
	TransactionID       string
	TransactionHash     string
	InputAddressID      string
	IsCoinbase          string
	Coinbase            string
	PrevoutHash         string
	PrevoutN            string
	PrevoutSpendUpdated string
	Sequence            string
	Value               string
	ScriptSigAsm        string
	ScriptSigHex        string
	Created             string
	Modified            string
	Vin                 string
	Witness             string
}{
	ID:                  "id",
	TransactionID:       "transaction_id",
	TransactionHash:     "transaction_hash",
	InputAddressID:      "input_address_id",
	IsCoinbase:          "is_coinbase",
	Coinbase:            "coinbase",
	PrevoutHash:         "prevout_hash",
	PrevoutN:            "prevout_n",
	PrevoutSpendUpdated: "prevout_spend_updated",
	Sequence:            "sequence",
	Value:               "value",
	ScriptSigAsm:        "script_sig_asm",
	ScriptSigHex:        "script_sig_hex",
	Created:             "created",
	Modified:            "modified",
	Vin:                 "vin",
	Witness:             "witness",
}
type whereHelpernull_Float64 struct{ field string }
func (w whereHelpernull_Float64) EQ(x null.Float64) qm.QueryMod {
	return qmhelper.WhereNullEQ(w.field, false, x)
}
func (w whereHelpernull_Float64) NEQ(x null.Float64) qm.QueryMod {
	return qmhelper.WhereNullEQ(w.field, true, x)
}
func (w whereHelpernull_Float64) IsNull() qm.QueryMod    { return qmhelper.WhereIsNull(w.field) }
func (w whereHelpernull_Float64) IsNotNull() qm.QueryMod { return qmhelper.WhereIsNotNull(w.field) }
func (w whereHelpernull_Float64) LT(x null.Float64) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LT, x)
}
func (w whereHelpernull_Float64) LTE(x null.Float64) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LTE, x)
}
func (w whereHelpernull_Float64) GT(x null.Float64) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GT, x)
}
func (w whereHelpernull_Float64) GTE(x null.Float64) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GTE, x)
}
var InputWhere = struct {
	ID                  whereHelperuint64
	TransactionID       whereHelperuint64
	TransactionHash     whereHelperstring
	InputAddressID      whereHelpernull_Uint64
	IsCoinbase          whereHelperbool
	Coinbase            whereHelpernull_String
	PrevoutHash         whereHelpernull_String
	PrevoutN            whereHelpernull_Uint
	PrevoutSpendUpdated whereHelperbool
	Sequence            whereHelperuint
	Value               whereHelpernull_Float64
	ScriptSigAsm        whereHelpernull_String
	ScriptSigHex        whereHelpernull_String
	Created             whereHelpertime_Time
	Modified            whereHelpertime_Time
	Vin                 whereHelpernull_Uint
	Witness             whereHelpernull_String
}{
	ID:                  whereHelperuint64{field: "`input`.`id`"},
	TransactionID:       whereHelperuint64{field: "`input`.`transaction_id`"},
	TransactionHash:     whereHelperstring{field: "`input`.`transaction_hash`"},
	InputAddressID:      whereHelpernull_Uint64{field: "`input`.`input_address_id`"},
	IsCoinbase:          whereHelperbool{field: "`input`.`is_coinbase`"},
	Coinbase:            whereHelpernull_String{field: "`input`.`coinbase`"},
	PrevoutHash:         whereHelpernull_String{field: "`input`.`prevout_hash`"},
	PrevoutN:            whereHelpernull_Uint{field: "`input`.`prevout_n`"},
	PrevoutSpendUpdated: whereHelperbool{field: "`input`.`prevout_spend_updated`"},
	Sequence:            whereHelperuint{field: "`input`.`sequence`"},
	Value:               whereHelpernull_Float64{field: "`input`.`value`"},
	ScriptSigAsm:        whereHelpernull_String{field: "`input`.`script_sig_asm`"},
	ScriptSigHex:        whereHelpernull_String{field: "`input`.`script_sig_hex`"},
	Created:             whereHelpertime_Time{field: "`input`.`created`"},
	Modified:            whereHelpertime_Time{field: "`input`.`modified`"},
	Vin:                 whereHelpernull_Uint{field: "`input`.`vin`"},
	Witness:             whereHelpernull_String{field: "`input`.`witness`"},
}
var InputRels = struct {
	Transaction string
}{
	Transaction: "Transaction",
}
type inputR struct {
	Transaction *Transaction
}
func (*inputR) NewStruct() *inputR {
	return &inputR{}
}
type inputL struct{}
var (
	inputAllColumns            = []string{"id", "transaction_id", "transaction_hash", "input_address_id", "is_coinbase", "coinbase", "prevout_hash", "prevout_n", "prevout_spend_updated", "sequence", "value", "script_sig_asm", "script_sig_hex", "created", "modified", "vin", "witness"}
	inputColumnsWithoutDefault = []string{"transaction_id", "transaction_hash", "input_address_id", "coinbase", "prevout_hash", "prevout_n", "sequence", "value", "script_sig_asm", "script_sig_hex", "vin", "witness"}
	inputColumnsWithDefault    = []string{"id", "is_coinbase", "prevout_spend_updated", "created", "modified"}
	inputPrimaryKeyColumns     = []string{"id"}
)
type (
	InputSlice []*Input
	inputQuery struct {
		*queries.Query
	}
)
var (
	inputType                 = reflect.TypeOf(&Input{})
	inputMapping              = queries.MakeStructMapping(inputType)
	inputPrimaryKeyMapping, _ = queries.BindMapping(inputType, inputMapping, inputPrimaryKeyColumns)
	inputInsertCacheMut       sync.RWMutex
	inputInsertCache          = make(map[string]insertCache)
	inputUpdateCacheMut       sync.RWMutex
	inputUpdateCache          = make(map[string]updateCache)
	inputUpsertCacheMut       sync.RWMutex
	inputUpsertCache          = make(map[string]insertCache)
)
var (
	_ = time.Second
	_ = qmhelper.Where
)
func (q inputQuery) OneG() (*Input, error) {
	return q.One(boil.GetDB())
}
func (q inputQuery) OneGP() *Input {
	o, err := q.One(boil.GetDB())
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q inputQuery) OneP(exec boil.Executor) *Input {
	o, err := q.One(exec)
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q inputQuery) One(exec boil.Executor) (*Input, error) {
	o := &Input{}
	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 input")
	}
	return o, nil
}
func (q inputQuery) AllG() (InputSlice, error) {
	return q.All(boil.GetDB())
}
func (q inputQuery) AllGP() InputSlice {
	o, err := q.All(boil.GetDB())
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q inputQuery) AllP(exec boil.Executor) InputSlice {
	o, err := q.All(exec)
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q inputQuery) All(exec boil.Executor) (InputSlice, error) {
	var o []*Input
	err := q.Bind(nil, exec, &o)
	if err != nil {
		return nil, errors.Wrap(err, "model: failed to assign all query results to Input slice")
	}
	return o, nil
}