func (q storageQuery) ExistsP() bool {
	e, err := q.Exists()
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return e
}
Exists checks if the row exists in the table, and panics on error.
package mdbmodels
import (
	"bytes"
	"database/sql"
	"fmt"
	"reflect"
	"strings"
	"sync"
	"time"
	"github.com/Bnei-Baruch/sqlboiler/boil"
	"github.com/Bnei-Baruch/sqlboiler/queries"
	"github.com/Bnei-Baruch/sqlboiler/queries/qm"
	"github.com/Bnei-Baruch/sqlboiler/strmangle"
	"github.com/pkg/errors"
)
type Storage struct {
	ID       int64  `boil:"id" json:"id" toml:"id" yaml:"id"`
	Name     string `boil:"name" json:"name" toml:"name" yaml:"name"`
	Country  string `boil:"country" json:"country" toml:"country" yaml:"country"`
	Location string `boil:"location" json:"location" toml:"location" yaml:"location"`
	Status   string `boil:"status" json:"status" toml:"status" yaml:"status"`
	Access   string `boil:"access" json:"access" toml:"access" yaml:"access"`
	R *storageR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L storageL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}
var StorageColumns = struct {
	ID       string
	Name     string
	Country  string
	Location string
	Status   string
	Access   string
}{
	ID:       "id",
	Name:     "name",
	Country:  "country",
	Location: "location",
	Status:   "status",
	Access:   "access",
}
type storageR struct {
	Files FileSlice
}
type storageL struct{}
var (
	storageColumns               = []string{"id", "name", "country", "location", "status", "access"}
	storageColumnsWithoutDefault = []string{"name", "country", "location", "status", "access"}
	storageColumnsWithDefault    = []string{"id"}
	storagePrimaryKeyColumns     = []string{"id"}
)
type (
	StorageSlice []*Storage
	storageQuery struct {
		*queries.Query
	}
)
var (
	storageType                 = reflect.TypeOf(&Storage{})
	storageMapping              = queries.MakeStructMapping(storageType)
	storagePrimaryKeyMapping, _ = queries.BindMapping(storageType, storageMapping, storagePrimaryKeyColumns)
	storageInsertCacheMut       sync.RWMutex
	storageInsertCache          = make(map[string]insertCache)
	storageUpdateCacheMut       sync.RWMutex
	storageUpdateCache          = make(map[string]updateCache)
	storageUpsertCacheMut       sync.RWMutex
	storageUpsertCache          = make(map[string]insertCache)
)
var (
	_ = time.Second
	_ = bytes.MinRead
)
func (q storageQuery) OneP() *Storage {
	o, err := q.One()
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q storageQuery) One() (*Storage, error) {
	o := &Storage{}
	queries.SetLimit(q.Query, 1)
	err := q.Bind(o)
	if err != nil {
		if errors.Cause(err) == sql.ErrNoRows {
			return nil, sql.ErrNoRows
		}
		return nil, errors.Wrap(err, "mdbmodels: failed to execute a one query for storages")
	}
	return o, nil
}
func (q storageQuery) AllP() StorageSlice {
	o, err := q.All()
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q storageQuery) All() (StorageSlice, error) {
	var o []*Storage
	err := q.Bind(&o)
	if err != nil {
		return nil, errors.Wrap(err, "mdbmodels: failed to assign all query results to Storage slice")
	}
	return o, nil
}
func (q storageQuery) CountP() int64 {
	c, err := q.Count()
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return c
}
func (q storageQuery) Count() (int64, error) {
	var count int64
	queries.SetSelect(q.Query, nil)
	queries.SetCount(q.Query)
	err := q.Query.QueryRow().Scan(&count)
	if err != nil {
		return 0, errors.Wrap(err, "mdbmodels: failed to count storages rows")
	}
	return count, nil
}