Documentation

Index

Constants

View Source
const (
	JoinInner joinKind = iota
	JoinOuterLeft
	JoinOuterRight
	JoinNatural
	JoinOuterFull
)

    Join type constants

    Variables

    This section is empty.

    Functions

    func AppendFrom

    func AppendFrom(q *Query, from ...string)

      AppendFrom on the query.

      func AppendFullOuterJoin

      func AppendFullOuterJoin(q *Query, clause string, args ...interface{})

        AppendFullOuterJoin on the query.

        func AppendGroupBy

        func AppendGroupBy(q *Query, clause string)

          AppendGroupBy on the query.

          func AppendHaving

          func AppendHaving(q *Query, clause string, args ...interface{})

            AppendHaving on the query.

            func AppendIn

            func AppendIn(q *Query, clause string, args ...interface{})

              AppendIn on the query.

              func AppendInnerJoin

              func AppendInnerJoin(q *Query, clause string, args ...interface{})

                AppendInnerJoin on the query.

                func AppendLeftOuterJoin

                func AppendLeftOuterJoin(q *Query, clause string, args ...interface{})

                  AppendLeftOuterJoin on the query.

                  func AppendLoad

                  func AppendLoad(q *Query, relationships string)

                    AppendLoad on the query.

                    func AppendOrderBy

                    func AppendOrderBy(q *Query, clause string, args ...interface{})

                      AppendOrderBy on the query.

                      func AppendRightOuterJoin

                      func AppendRightOuterJoin(q *Query, clause string, args ...interface{})

                        AppendRightOuterJoin on the query.

                        func AppendSelect

                        func AppendSelect(q *Query, columns ...string)

                          AppendSelect on the query.

                          func AppendWhere

                          func AppendWhere(q *Query, clause string, args ...interface{})

                            AppendWhere on the query.

                            func AppendWhereLeftParen

                            func AppendWhereLeftParen(q *Query)

                              AppendWhereLeftParen creates a right left in the where expression

                              func AppendWhereRightParen

                              func AppendWhereRightParen(q *Query)

                                AppendWhereRightParen creates a right paren in the where expression

                                func AppendWith

                                func AppendWith(q *Query, clause string, args ...interface{})

                                  AppendWith on the query.

                                  func Assign

                                  func Assign(dst, src interface{})

                                    Assign assigns a value to another using reflection. Dst must be a pointer.

                                    func Bind

                                    func Bind(rows *sql.Rows, obj interface{}) error

                                      Bind inserts the rows into the passed in object pointer, because the caller owns the rows it is imperative to note that the caller MUST both close the rows and check for errors on the rows.

                                      If you neglect closing the rows your application may have a memory leak if the rows are not implicitly closed by iteration alone. If you neglect checking the rows.Err silent failures may occur in your application.

                                      Valid types to bind to are: *Struct, []*Struct, and []Struct. Keep in mind if you use []Struct that Bind will be doing copy-by-value as a method of keeping heap memory usage low which means if your Struct contains reference types/pointers you will see incorrect results, do not use []Struct with a Struct with reference types.

                                      Bind rules:

                                      - Struct tags control bind, in the form of: `boil:"name,bind"`
                                      - If "name" is omitted the sql column names that come back are TitleCased
                                        and matched against the field name.
                                      - If the "name" part of the struct tag is specified, the given name will
                                        be used instead of the struct field name for binding.
                                      - If the "name" of the struct tag is "-", this field will not be bound to.
                                      - If the ",bind" option is specified on a struct field and that field
                                        is a struct itself, it will be recursed into to look for fields for
                                        binding.
                                      

                                      Example usage:

                                      type JoinStruct struct {
                                        // User1 can have it's struct fields bound to since it specifies
                                        // ,bind in the struct tag, it will look specifically for
                                        // fields that are prefixed with "user." returning from the query.
                                        // For example "user.id" column name will bind to User1.ID
                                        User1      *models.User `boil:"user,bind"`
                                        // User2 will follow the same rules as noted above except it will use
                                        // "friend." as the prefix it's looking for.
                                        User2      *models.User `boil:"friend,bind"`
                                        // RandomData will not be recursed into to look for fields to
                                        // bind and will not be bound to because of the - for the name.
                                        RandomData myStruct     `boil:"-"`
                                        // Date will not be recursed into to look for fields to bind because
                                        // it does not specify ,bind in the struct tag. But it can be bound to
                                        // as it does not specify a - for the name.
                                        Date       time.Time
                                      }
                                      
                                      models.Users(
                                        qm.InnerJoin("users as friend on users.friend_id = friend.id")
                                      ).Bind(&joinStruct)
                                      

                                      For custom objects that want to use eager loading, please see the loadRelationships function.

                                      func BindMapping

                                      func BindMapping(typ reflect.Type, mapping map[string]uint64, cols []string) ([]uint64, error)

                                        BindMapping creates a mapping that helps look up the pointer for the column given.

                                        func BuildQuery

                                        func BuildQuery(q *Query) (string, []interface{})

                                          BuildQuery builds a query object into the query string and it's accompanying arguments. Using this method allows query building without immediate execution.

                                          func Equal

                                          func Equal(a, b interface{}) bool

                                            Equal is different to reflect.DeepEqual in that it's both less efficient less magical, and dosen't concern itself with a wide variety of types that could be present but it does use the driver.Valuer interface since many types that will go through database things will use these.

                                            We're focused on basic types + []byte. Since we're really only interested in things that are typically used for primary keys in a database.

                                            Choosing not to use the DefaultParameterConverter here because sqlboiler doesn't generate pointer columns.

                                            func GetSelect

                                            func GetSelect(q *Query) []string

                                              GetSelect from the query

                                              func IsNil

                                              func IsNil(val interface{}) bool

                                                IsNil is a more generic version of IsValuerNil, will check to make sure it's not a valuer first.

                                                func IsValuerNil

                                                func IsValuerNil(val driver.Valuer) bool

                                                  IsValuerNil returns true if the valuer's value is null.

                                                  func MakeStructMapping

                                                  func MakeStructMapping(typ reflect.Type) map[string]uint64

                                                    MakeStructMapping creates a map of the struct to be able to quickly look up its pointers and values by name.

                                                    func MustTime

                                                    func MustTime(val driver.Valuer) time.Time

                                                      MustTime retrieves a time value from a valuer.

                                                      func NonZeroDefaultSet

                                                      func NonZeroDefaultSet(defaults []string, obj interface{}) []string

                                                        NonZeroDefaultSet returns the fields included in the defaults slice that are non zero values

                                                        func PtrsFromMapping

                                                        func PtrsFromMapping(val reflect.Value, mapping []uint64) []interface{}

                                                          PtrsFromMapping expects to be passed an addressable struct and a mapping of where to find things. It pulls the pointers out referred to by the mapping.

                                                          func SetArgs

                                                          func SetArgs(q *Query, args ...interface{})

                                                            SetArgs is primarily for re-use of a query so that the query text does not need to be re-generated, useful if you're performing the same query with different arguments over and over.

                                                            func SetCount

                                                            func SetCount(q *Query)

                                                              SetCount on the query.

                                                              func SetDelete

                                                              func SetDelete(q *Query)

                                                                SetDelete on the query.

                                                                func SetDialect

                                                                func SetDialect(q *Query, dialect *drivers.Dialect)

                                                                  SetDialect on the query.

                                                                  func SetDistinct

                                                                  func SetDistinct(q *Query, distinct string)

                                                                    SetDistinct on the query.

                                                                    func SetFor

                                                                    func SetFor(q *Query, clause string)

                                                                      SetFor on the query.

                                                                      func SetFrom

                                                                      func SetFrom(q *Query, from ...string)

                                                                        SetFrom replaces the current from statements.

                                                                        func SetLastInAsOr

                                                                        func SetLastInAsOr(q *Query)

                                                                          SetLastInAsOr is an alias for SetLastWhereAsOr

                                                                          func SetLastWhereAsOr

                                                                          func SetLastWhereAsOr(q *Query)

                                                                            SetLastWhereAsOr sets the or separator for the tail "WHERE" in the slice

                                                                            func SetLimit

                                                                            func SetLimit(q *Query, limit int)

                                                                              SetLimit on the query.

                                                                              func SetLoad

                                                                              func SetLoad(q *Query, relationships ...string)

                                                                                SetLoad on the query.

                                                                                func SetLoadMods

                                                                                func SetLoadMods(q *Query, rel string, appl Applicator)

                                                                                  SetLoadMods on the query.

                                                                                  func SetOffset

                                                                                  func SetOffset(q *Query, offset int)

                                                                                    SetOffset on the query.

                                                                                    func SetSQL

                                                                                    func SetSQL(q *Query, sql string, args ...interface{})

                                                                                      SetSQL on the query.

                                                                                      func SetScanner

                                                                                      func SetScanner(scanner sql.Scanner, val driver.Value)

                                                                                        SetScanner attempts to set a scannable value on a scanner.

                                                                                        func SetSelect

                                                                                        func SetSelect(q *Query, sel []string)

                                                                                          SetSelect on the query.

                                                                                          func SetUpdate

                                                                                          func SetUpdate(q *Query, cols map[string]interface{})

                                                                                            SetUpdate on the query.

                                                                                            func ValuesFromMapping

                                                                                            func ValuesFromMapping(val reflect.Value, mapping []uint64) []interface{}

                                                                                              ValuesFromMapping expects to be passed an addressable struct and a mapping of where to find things. It pulls the pointers out referred to by the mapping.

                                                                                              Types

                                                                                              type Applicator

                                                                                              type Applicator interface {
                                                                                              	Apply(*Query)
                                                                                              }

                                                                                                Applicator exists only to allow query mods into the query struct around eager loaded relationships.

                                                                                                type Query

                                                                                                type Query struct {
                                                                                                	// contains filtered or unexported fields
                                                                                                }

                                                                                                  Query holds the state for the built up query

                                                                                                  func Raw

                                                                                                  func Raw(query string, args ...interface{}) *Query

                                                                                                    Raw makes a raw query, usually for use with bind

                                                                                                    func RawG

                                                                                                    func RawG(query string, args ...interface{}) *Query

                                                                                                      RawG makes a raw query using the global boil.Executor, usually for use with bind

                                                                                                      func (*Query) Bind

                                                                                                      func (q *Query) Bind(ctx context.Context, exec boil.Executor, obj interface{}) error

                                                                                                        Bind executes the query and inserts the result into the passed in object pointer.

                                                                                                        If Context is non-nil it will upgrade the Executor to a ContextExecutor and query with the passed context. If Context is non-nil, any eager loading that's done must also be using load* methods that support context as the first parameter.

                                                                                                        Also see documentation for Bind()

                                                                                                        func (*Query) BindG

                                                                                                        func (q *Query) BindG(ctx context.Context, obj interface{}) error

                                                                                                          BindG executes the query and inserts the result into the passed in object pointer. It uses the global executor. Also see documentation for Bind() and Query.Bind()

                                                                                                          func (*Query) BindP

                                                                                                          func (q *Query) BindP(ctx context.Context, exec boil.Executor, obj interface{})

                                                                                                            BindP executes the query and inserts the result into the passed in object pointer. It panics on error. Also see documentation for Bind() and Query.Bind()

                                                                                                            func (*Query) Exec

                                                                                                            func (q *Query) Exec(exec boil.Executor) (sql.Result, error)

                                                                                                              Exec executes a query that does not need a row returned

                                                                                                              func (*Query) ExecContext

                                                                                                              func (q *Query) ExecContext(ctx context.Context, exec boil.ContextExecutor) (sql.Result, error)

                                                                                                                ExecContext executes a query that does not need a row returned

                                                                                                                func (*Query) ExecP

                                                                                                                func (q *Query) ExecP(exec boil.Executor) sql.Result

                                                                                                                  ExecP executes a query that does not need a row returned It will panic on error

                                                                                                                  func (*Query) Query

                                                                                                                  func (q *Query) Query(exec boil.Executor) (*sql.Rows, error)

                                                                                                                    Query executes the query for the All finisher and returns multiple rows

                                                                                                                    func (*Query) QueryContext

                                                                                                                    func (q *Query) QueryContext(ctx context.Context, exec boil.ContextExecutor) (*sql.Rows, error)

                                                                                                                      QueryContext executes the query for the All finisher and returns multiple rows

                                                                                                                      func (*Query) QueryP

                                                                                                                      func (q *Query) QueryP(exec boil.Executor) *sql.Rows

                                                                                                                        QueryP executes the query for the All finisher and returns multiple rows It will panic on error

                                                                                                                        func (*Query) QueryRow

                                                                                                                        func (q *Query) QueryRow(exec boil.Executor) *sql.Row

                                                                                                                          QueryRow executes the query for the One finisher and returns a row

                                                                                                                          func (*Query) QueryRowContext

                                                                                                                          func (q *Query) QueryRowContext(ctx context.Context, exec boil.ContextExecutor) *sql.Row

                                                                                                                            QueryRowContext executes the query for the One finisher and returns a row

                                                                                                                            Directories

                                                                                                                            Path Synopsis