pg: github.com/go-pg/pg/orm Index | Files

package orm

import "github.com/go-pg/pg/orm"

Index

Package Files

composite.go composite_create.go composite_drop.go composite_parser.go count_estimate.go delete.go field.go format.go hook.go inflection.go insert.go join.go model.go model_discard.go model_func.go model_scan.go model_slice.go model_table.go model_table_m2m.go model_table_many.go model_table_slice.go model_table_struct.go orm.go query.go relation.go result.go select.go struct_filter.go table.go table_create.go table_drop.go table_params.go tables.go types.go update.go util.go

Constants

const (
    PrimaryKeyFlag = uint8(1) << iota
    ForeignKeyFlag
    NotNullFlag
    UniqueFlag
    ArrayFlag
)
const (
    HasOneRelation = 1 << iota
    BelongsToRelation
    HasManyRelation
    Many2ManyRelation
)
const (
    AfterScanHookFlag = uint16(1) << iota
    AfterSelectHookFlag
    BeforeInsertHookFlag
    AfterInsertHookFlag
    BeforeUpdateHookFlag
    AfterUpdateHookFlag
    BeforeDeleteHookFlag
    AfterDeleteHookFlag
)

func CreateComposite Uses

func CreateComposite(db DB, model interface{}, opt *CreateCompositeOptions) error

func CreateTable Uses

func CreateTable(db DB, model interface{}, opt *CreateTableOptions) error

func Delete Uses

func Delete(db DB, model interface{}) error

Delete deletes a given model from the db

func DropComposite Uses

func DropComposite(db DB, model interface{}, opt *DropCompositeOptions) error

func DropTable Uses

func DropTable(db DB, model interface{}, opt *DropTableOptions) error

func ForceDelete Uses

func ForceDelete(db DB, model interface{}) error

ForceDelete force deletes a given model from the db

func Insert Uses

func Insert(db DB, model ...interface{}) error

func OnUpdate Uses

func OnUpdate(fks []*Field) string

func Q Uses

func Q(query string, params ...interface{}) *queryParamsAppender

nolint

func RegisterTable Uses

func RegisterTable(strct interface{})

RegisterTable registers a struct as SQL table. It is usually used to register intermediate table in many to many relationship.

func Scan Uses

func Scan(values ...interface{}) scanValuesModel

nolint

func Select Uses

func Select(db DB, model interface{}) error

func SetTableNameInflector Uses

func SetTableNameInflector(fn func(string) string)

SetTableNameInflector overrides the default func that pluralizes model name to get table name, e.g. my_article becomes my_articles.

func Update Uses

func Update(db DB, model interface{}) error

type AfterDeleteHook Uses

type AfterDeleteHook interface {
    AfterDelete(context.Context) error
}

type AfterInsertHook Uses

type AfterInsertHook interface {
    AfterInsert(context.Context) error
}

type AfterScanHook Uses

type AfterScanHook interface {
    AfterScan(context.Context) error
}

type AfterSelectHook Uses

type AfterSelectHook interface {
    AfterSelect(context.Context) error
}

type AfterUpdateHook Uses

type AfterUpdateHook interface {
    AfterUpdate(context.Context) error
}

type BeforeDeleteHook Uses

type BeforeDeleteHook interface {
    BeforeDelete(context.Context) (context.Context, error)
}

type BeforeInsertHook Uses

type BeforeInsertHook interface {
    BeforeInsert(context.Context) (context.Context, error)
}

type BeforeUpdateHook Uses

type BeforeUpdateHook interface {
    BeforeUpdate(context.Context) (context.Context, error)
}

type ColumnScanner Uses

type ColumnScanner interface {
    // Scan assigns a column value from a row.
    //
    // An error should be returned if the value can not be stored
    // without loss of information.
    ScanColumn(colIdx int, colName string, rd types.Reader, n int) error
}

ColumnScanner is used to scan column values.

type CreateCompositeOptions Uses

type CreateCompositeOptions struct {
    Varchar int // replaces PostgreSQL data type `text` with `varchar(n)`
}

type CreateTableOptions Uses

type CreateTableOptions struct {
    Varchar     int // replaces PostgreSQL data type `text` with `varchar(n)`
    Temp        bool
    IfNotExists bool

    // FKConstraints causes CreateTable to create foreign key constraints
    // for has one relations. ON DELETE hook can be added using tag
    // `sql:"on_delete:RESTRICT"` on foreign key field. ON UPDATE hook can be added using tag
    // `sql:"on_update:CASCADE"`
    FKConstraints bool
}

type DB Uses

type DB interface {
    Model(model ...interface{}) *Query
    ModelContext(c context.Context, model ...interface{}) *Query
    Select(model interface{}) error
    Insert(model ...interface{}) error
    Update(model interface{}) error
    Delete(model interface{}) error
    ForceDelete(model interface{}) error

    Exec(query interface{}, params ...interface{}) (Result, error)
    ExecContext(c context.Context, query interface{}, params ...interface{}) (Result, error)
    ExecOne(query interface{}, params ...interface{}) (Result, error)
    ExecOneContext(c context.Context, query interface{}, params ...interface{}) (Result, error)
    Query(model, query interface{}, params ...interface{}) (Result, error)
    QueryContext(c context.Context, model, query interface{}, params ...interface{}) (Result, error)
    QueryOne(model, query interface{}, params ...interface{}) (Result, error)
    QueryOneContext(c context.Context, model, query interface{}, params ...interface{}) (Result, error)

    CopyFrom(r io.Reader, query interface{}, params ...interface{}) (Result, error)
    CopyTo(w io.Writer, query interface{}, params ...interface{}) (Result, error)

    Context() context.Context
    QueryFormatter
}

DB is a common interface for pg.DB and pg.Tx types.

type Discard Uses

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

func (Discard) AddColumnScanner Uses

func (m Discard) AddColumnScanner(ColumnScanner) error

func (Discard) AfterDelete Uses

func (Discard) AfterDelete(c context.Context) error

func (Discard) AfterInsert Uses

func (Discard) AfterInsert(c context.Context) error

func (Discard) AfterSelect Uses

func (Discard) AfterSelect(c context.Context) error

func (Discard) AfterUpdate Uses

func (Discard) AfterUpdate(c context.Context) error

func (Discard) BeforeDelete Uses

func (Discard) BeforeDelete(c context.Context) (context.Context, error)

func (Discard) BeforeInsert Uses

func (Discard) BeforeInsert(c context.Context) (context.Context, error)

func (Discard) BeforeUpdate Uses

func (Discard) BeforeUpdate(c context.Context) (context.Context, error)

func (Discard) Init Uses

func (Discard) Init() error

func (Discard) NextColumnScanner Uses

func (m Discard) NextColumnScanner() ColumnScanner

func (Discard) ScanColumn Uses

func (m Discard) ScanColumn(colIdx int, colName string, rd types.Reader, n int) error

type DropCompositeOptions Uses

type DropCompositeOptions struct {
    IfExists bool
    Cascade  bool
}

type DropTableOptions Uses

type DropTableOptions struct {
    IfExists bool
    Cascade  bool
}

type Field Uses

type Field struct {
    Field reflect.StructField
    Type  reflect.Type

    GoName   string  // struct field name, e.g. Id
    SQLName  string  // SQL name, .e.g. id
    Column   types.Q // escaped SQL name, e.g. "id"
    SQLType  string
    Index    []int
    Default  types.Q
    OnDelete string
    OnUpdate string
    // contains filtered or unexported fields
}

func (*Field) AppendValue Uses

func (f *Field) AppendValue(b []byte, strct reflect.Value, quote int) []byte

func (*Field) Clone Uses

func (f *Field) Clone() *Field

func (*Field) HasFlag Uses

func (f *Field) HasFlag(flag uint8) bool

func (*Field) IsZeroValue Uses

func (f *Field) IsZeroValue(strct reflect.Value) bool

func (*Field) OmitZero Uses

func (f *Field) OmitZero() bool

func (*Field) ScanValue Uses

func (f *Field) ScanValue(strct reflect.Value, rd types.Reader, n int) error

func (*Field) SetFlag Uses

func (f *Field) SetFlag(flag uint8)

func (*Field) Value Uses

func (f *Field) Value(strct reflect.Value) reflect.Value

type Formatter Uses

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

func (Formatter) FormatQuery Uses

func (f Formatter) FormatQuery(dst []byte, query string, params ...interface{}) []byte

func (Formatter) FormatQueryBytes Uses

func (f Formatter) FormatQueryBytes(dst, query []byte, params ...interface{}) []byte

func (Formatter) Param Uses

func (f Formatter) Param(param string) interface{}

func (Formatter) String Uses

func (f Formatter) String() string

func (Formatter) WithModel Uses

func (f Formatter) WithModel(model interface{}) Formatter

func (Formatter) WithParam Uses

func (f Formatter) WithParam(param string, value interface{}) Formatter

type HooklessModel Uses

type HooklessModel interface {
    // Init is responsible to initialize/reset model state.
    // It is called only once no matter how many rows were returned.
    Init() error

    // NextColumnScanner returns a ColumnScanner that is used to scan columns
    // from the current row. It is called once for every row.
    NextColumnScanner() ColumnScanner

    // AddColumnScanner adds the ColumnScanner to the model.
    AddColumnScanner(ColumnScanner) error
}

type Method Uses

type Method struct {
    Index int
    // contains filtered or unexported fields
}

func (*Method) AppendValue Uses

func (m *Method) AppendValue(dst []byte, strct reflect.Value, quote int) []byte

func (*Method) Has Uses

func (m *Method) Has(flag int8) bool

func (*Method) Value Uses

func (m *Method) Value(strct reflect.Value) reflect.Value

type Model Uses

type Model interface {
    HooklessModel

    AfterSelectHook

    BeforeInsertHook
    AfterInsertHook

    BeforeUpdateHook
    AfterUpdateHook

    BeforeDeleteHook
    AfterDeleteHook
}

func NewModel Uses

func NewModel(values ...interface{}) (Model, error)

type Query Uses

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

func NewQuery Uses

func NewQuery(db DB, model ...interface{}) *Query

func NewQueryContext Uses

func NewQueryContext(c context.Context, db DB, model ...interface{}) *Query

func (*Query) AllWithDeleted Uses

func (q *Query) AllWithDeleted() *Query

AllWithDeleted changes query to return all rows including soft deleted ones.

func (*Query) AppendQuery Uses

func (q *Query) AppendQuery(fmter QueryFormatter, b []byte) ([]byte, error)

func (*Query) Apply Uses

func (q *Query) Apply(fn func(*Query) (*Query, error)) *Query

Apply calls the fn passing the Query as an argument.

func (*Query) Clone Uses

func (q *Query) Clone() *Query

Clone clones the Query.

func (*Query) Column Uses

func (q *Query) Column(columns ...string) *Query

Column adds a column to the Query quoting it according to PostgreSQL rules. Does not expand params like ?TableAlias etc. ColumnExpr can be used to bypass quoting restriction or for params expansion. Column name can be:

- column_name,
- table_alias.column_name,
- table_alias.*.

func (*Query) ColumnExpr Uses

func (q *Query) ColumnExpr(expr string, params ...interface{}) *Query

ColumnExpr adds column expression to the Query.

func (*Query) Context Uses

func (q *Query) Context(c context.Context) *Query

func (*Query) CopyFrom Uses

func (q *Query) CopyFrom(r io.Reader, query interface{}, params ...interface{}) (Result, error)

CopyFrom is an alias from DB.CopyFrom.

func (*Query) CopyTo Uses

func (q *Query) CopyTo(w io.Writer, query interface{}, params ...interface{}) (Result, error)

CopyTo is an alias from DB.CopyTo.

func (*Query) Count Uses

func (q *Query) Count() (int, error)

Count returns number of rows matching the query using count aggregate function.

func (*Query) CountEstimate Uses

func (q *Query) CountEstimate(threshold int) (int, error)

CountEstimate uses EXPLAIN to get estimated number of rows returned the query. If that number is bigger than the threshold it returns the estimation. Otherwise it executes another query using count aggregate function and returns the result.

Based on https://wiki.postgresql.org/wiki/Count_estimate

func (*Query) CreateTable Uses

func (q *Query) CreateTable(opt *CreateTableOptions) error

func (*Query) DB Uses

func (q *Query) DB(db DB) *Query

func (*Query) Delete Uses

func (q *Query) Delete(values ...interface{}) (Result, error)

Delete deletes the model. When model has deleted_at column the row is soft deleted instead.

func (*Query) Deleted Uses

func (q *Query) Deleted() *Query

Deleted adds `WHERE deleted_at IS NOT NULL` clause for soft deleted models.

func (*Query) Distinct Uses

func (q *Query) Distinct() *Query

func (*Query) DistinctOn Uses

func (q *Query) DistinctOn(expr string, params ...interface{}) *Query

func (*Query) DropTable Uses

func (q *Query) DropTable(opt *DropTableOptions) error

func (*Query) ExcludeColumn Uses

func (q *Query) ExcludeColumn(columns ...string) *Query

ExcludeColumn excludes a column from the list of to be selected columns.

func (*Query) Exec Uses

func (q *Query) Exec(query interface{}, params ...interface{}) (Result, error)

Exec is an alias for DB.Exec.

func (*Query) ExecOne Uses

func (q *Query) ExecOne(query interface{}, params ...interface{}) (Result, error)

ExecOne is an alias for DB.ExecOne.

func (*Query) Exists Uses

func (q *Query) Exists() (bool, error)

Exists returns true or false depending if there are any rows matching the query.

func (*Query) First Uses

func (q *Query) First() error

First sorts rows by primary key and selects the first row. It is a shortcut for:

q.OrderExpr("id ASC").Limit(1)

func (*Query) For Uses

func (q *Query) For(s string, params ...interface{}) *Query

func (*Query) ForEach Uses

func (q *Query) ForEach(fn interface{}) error

ForEach calls the function for each row returned by the query without loading all rows into the memory.

Function can accept a struct, a pointer to a struct, an orm.Model, or values for the columns in a row. Function must return an error.

func (*Query) ForceDelete Uses

func (q *Query) ForceDelete(values ...interface{}) (Result, error)

Delete forces delete of the model with deleted_at column.

func (*Query) GetModel Uses

func (q *Query) GetModel() TableModel

func (*Query) Group Uses

func (q *Query) Group(columns ...string) *Query

func (*Query) GroupExpr Uses

func (q *Query) GroupExpr(group string, params ...interface{}) *Query

func (*Query) Having Uses

func (q *Query) Having(having string, params ...interface{}) *Query

func (*Query) Insert Uses

func (q *Query) Insert(values ...interface{}) (Result, error)

Insert inserts the model.

func (*Query) Join Uses

func (q *Query) Join(join string, params ...interface{}) *Query

func (*Query) JoinOn Uses

func (q *Query) JoinOn(condition string, params ...interface{}) *Query

JoinOn appends join condition to the last join.

func (*Query) JoinOnOr Uses

func (q *Query) JoinOnOr(condition string, params ...interface{}) *Query

func (*Query) Last Uses

func (q *Query) Last() error

Last sorts rows by primary key and selects the last row. It is a shortcut for:

q.OrderExpr("id DESC").Limit(1)

func (*Query) Limit Uses

func (q *Query) Limit(n int) *Query

func (*Query) Model Uses

func (q *Query) Model(model ...interface{}) *Query

func (*Query) New Uses

func (q *Query) New() *Query

New returns new zero Query binded to the current db.

func (*Query) Offset Uses

func (q *Query) Offset(n int) *Query

func (*Query) OnConflict Uses

func (q *Query) OnConflict(s string, params ...interface{}) *Query

func (*Query) Order Uses

func (q *Query) Order(orders ...string) *Query

Order adds sort order to the Query quoting column name. Does not expand params like ?TableAlias etc. OrderExpr can be used to bypass quoting restriction or for params expansion.

func (*Query) OrderExpr Uses

func (q *Query) OrderExpr(order string, params ...interface{}) *Query

Order adds sort order to the Query.

func (*Query) Query Uses

func (q *Query) Query(model, query interface{}, params ...interface{}) (Result, error)

Query is an alias for DB.Query.

func (*Query) QueryOne Uses

func (q *Query) QueryOne(model, query interface{}, params ...interface{}) (Result, error)

QueryOne is an alias for DB.QueryOne.

func (*Query) Relation Uses

func (q *Query) Relation(name string, apply ...func(*Query) (*Query, error)) *Query

Relation adds a relation to the query. Relation name can be:

- RelationName to select all columns,
- RelationName.column_name,
- RelationName._ to join relation without selecting relation columns.

func (*Query) Returning Uses

func (q *Query) Returning(s string, params ...interface{}) *Query

Returning adds a RETURNING clause to the query.

`Returning("NULL")` can be used to suppress default returning clause generated by go-pg for INSERT queries to get values for null columns.

func (*Query) Select Uses

func (q *Query) Select(values ...interface{}) error

Select selects the model.

func (*Query) SelectAndCount Uses

func (q *Query) SelectAndCount(values ...interface{}) (count int, firstErr error)

SelectAndCount runs Select and Count in two goroutines, waits for them to finish and returns the result. If query limit is -1 it does not select any data and only counts the results.

func (*Query) SelectAndCountEstimate Uses

func (q *Query) SelectAndCountEstimate(threshold int, values ...interface{}) (count int, firstErr error)

SelectAndCountEstimate runs Select and CountEstimate in two goroutines, waits for them to finish and returns the result. If query limit is -1 it does not select any data and only counts the results.

func (*Query) SelectOrInsert Uses

func (q *Query) SelectOrInsert(values ...interface{}) (inserted bool, _ error)

SelectOrInsert selects the model inserting one if it does not exist. It returns true when model was inserted.

func (*Query) Set Uses

func (q *Query) Set(set string, params ...interface{}) *Query

func (*Query) Table Uses

func (q *Query) Table(tables ...string) *Query

func (*Query) TableExpr Uses

func (q *Query) TableExpr(expr string, params ...interface{}) *Query

func (*Query) Update Uses

func (q *Query) Update(scan ...interface{}) (Result, error)

Update updates the model.

func (*Query) UpdateNotNull Uses

func (q *Query) UpdateNotNull(scan ...interface{}) (Result, error)

Update updates the model omitting null columns.

func (*Query) Value Uses

func (q *Query) Value(column string, value string, params ...interface{}) *Query

Value overwrites model value for the column in INSERT and UPDATE queries.

func (*Query) Where Uses

func (q *Query) Where(condition string, params ...interface{}) *Query

func (*Query) WhereGroup Uses

func (q *Query) WhereGroup(fn func(*Query) (*Query, error)) *Query

WhereGroup encloses conditions added in the function in parentheses.

q.Where("TRUE").
	WhereGroup(func(q *orm.Query) (*orm.Query, error) {
		q = q.WhereOr("FALSE").WhereOr("TRUE").
		return q, nil
	})

generates

WHERE TRUE AND (FALSE OR TRUE)

func (*Query) WhereIn Uses

func (q *Query) WhereIn(where string, slice interface{}) *Query

WhereIn is a shortcut for Where and pg.In:

func (*Query) WhereInMulti Uses

func (q *Query) WhereInMulti(where string, values ...interface{}) *Query

WhereInMulti is a shortcut for Where and pg.InMulti:

func (*Query) WhereNotGroup Uses

func (q *Query) WhereNotGroup(fn func(*Query) (*Query, error)) *Query

WhereGroup encloses conditions added in the function in parentheses.

q.Where("TRUE").
	WhereNotGroup(func(q *orm.Query) (*orm.Query, error) {
		q = q.WhereOr("FALSE").WhereOr("TRUE").
		return q, nil
	})

generates

WHERE TRUE AND NOT (FALSE OR TRUE)

func (*Query) WhereOr Uses

func (q *Query) WhereOr(condition string, params ...interface{}) *Query

func (*Query) WhereOrGroup Uses

func (q *Query) WhereOrGroup(fn func(*Query) (*Query, error)) *Query

WhereOrGroup encloses conditions added in the function in parentheses.

q.Where("TRUE").
	WhereOrGroup(func(q *orm.Query) (*orm.Query, error) {
		q = q.Where("FALSE").Where("TRUE").
		return q, nil
	})

generates

WHERE TRUE OR (FALSE AND TRUE)

func (*Query) WhereOrNotGroup Uses

func (q *Query) WhereOrNotGroup(fn func(*Query) (*Query, error)) *Query

WhereOrGroup encloses conditions added in the function in parentheses.

q.Where("TRUE").
	WhereOrGroup(func(q *orm.Query) (*orm.Query, error) {
		q = q.Where("FALSE").Where("TRUE").
		return q, nil
	})

generates

WHERE TRUE OR NOT (FALSE AND TRUE)

func (*Query) WherePK Uses

func (q *Query) WherePK() *Query

WherePK adds condition based on the model primary keys. Usually it is the same as:

Where("id = ?id")

func (*Query) WhereStruct Uses

func (q *Query) WhereStruct(strct interface{}) *Query

WhereStruct generates conditions for the struct fields with non-zero values:

- Foo int - Where("foo = ?", strct.Foo)
- Foo []int - Where("foo = ANY(?)", pg.Array(strct.Foo))
- FooNEQ int - Where("foo != ?", strct.Foo)
- FooExclude int - Where("foo != ?", strct.Foo)
- FooGT int - Where("foo > ?", strct.Foo)
- FooGTE int - Where("foo >= ?", strct.Foo)
- FooLT int - Where("foo < ?", strct.Foo)
- FooLTE int - Where("foo <= ?", strct.Foo)

urlvalues.Decode can be used to decode url.Values into the struct.

Following field tags are recognized:

- pg:"-" - field is ignored.
- pg:",nowhere" - field is decoded but is ignored by WhereStruct.
- pg:",nodecode" - field is not decoded but is used by WhereStruct.
- pg:",required" - condition is added for zero values as well.

func (*Query) With Uses

func (q *Query) With(name string, subq *Query) *Query

With adds subq as common table expression with the given name.

func (*Query) WithDelete Uses

func (q *Query) WithDelete(name string, subq *Query) *Query

func (*Query) WithInsert Uses

func (q *Query) WithInsert(name string, subq *Query) *Query

func (*Query) WithUpdate Uses

func (q *Query) WithUpdate(name string, subq *Query) *Query

func (*Query) WrapWith Uses

func (q *Query) WrapWith(name string) *Query

WrapWith creates new Query and adds to it current query as common table expression with the given name.

type QueryAppender Uses

type QueryAppender interface {
    AppendQuery(fmter QueryFormatter, b []byte) ([]byte, error)
}

type QueryFormatter Uses

type QueryFormatter interface {
    FormatQuery(b []byte, query string, params ...interface{}) []byte
}

type Relation Uses

type Relation struct {
    Type        int
    Field       *Field
    JoinTable   *Table
    FKs         []*Field
    Polymorphic *Field
    FKValues    []*Field

    M2MTableName  types.Q
    M2MTableAlias types.Q
    BaseFKs       []string
    JoinFKs       []string
}

func (*Relation) String Uses

func (r *Relation) String() string

type Result Uses

type Result interface {
    Model() Model

    // RowsAffected returns the number of rows affected by SELECT, INSERT, UPDATE,
    // or DELETE queries. It returns -1 if query can't possibly affect any rows,
    // e.g. in case of CREATE or SHOW queries.
    RowsAffected() int

    // RowsReturned returns the number of rows returned by the query.
    RowsReturned() int
}

Result summarizes an executed SQL command.

type Table Uses

type Table struct {
    Type reflect.Type

    TypeName  string
    Alias     types.Q
    ModelName string

    Name               string
    FullName           types.Q
    FullNameForSelects types.Q

    Tablespace types.Q

    PartitionBy string

    Fields     []*Field // PKs + DataFields
    PKs        []*Field
    DataFields []*Field

    FieldsMap map[string]*Field

    Methods   map[string]*Method
    Relations map[string]*Relation
    Unique    map[string][]*Field

    SoftDeleteField *Field
    // contains filtered or unexported fields
}

Table represents a SQL table created from Go struct.

func GetTable Uses

func GetTable(typ reflect.Type) *Table

GetTable returns a Table for a struct type.

func (*Table) AddField Uses

func (t *Table) AddField(field *Field)

func (*Table) AppendParam Uses

func (t *Table) AppendParam(b []byte, strct reflect.Value, name string) ([]byte, bool)

func (*Table) GetField Uses

func (t *Table) GetField(name string) (*Field, error)

func (*Table) HasField Uses

func (t *Table) HasField(name string) bool

func (*Table) HasFlag Uses

func (t *Table) HasFlag(flag uint16) bool

func (*Table) RemoveField Uses

func (t *Table) RemoveField(field *Field)

func (*Table) SetFlag Uses

func (t *Table) SetFlag(flag uint16)

func (*Table) String Uses

func (t *Table) String() string

type TableModel Uses

type TableModel interface {
    Model

    IsNil() bool
    Table() *Table
    Relation() *Relation
    AppendParam(QueryFormatter, []byte, string) ([]byte, bool)

    Join(string, func(*Query) (*Query, error)) *join
    GetJoin(string) *join
    GetJoins() []join
    AddJoin(join) *join

    Root() reflect.Value
    Index() []int
    ParentIndex() []int
    Mount(reflect.Value)
    Kind() reflect.Kind
    Value() reflect.Value
    // contains filtered or unexported methods
}

type TemplateAppender Uses

type TemplateAppender interface {
    AppendTemplate(b []byte) ([]byte, error)
}

Package orm imports 22 packages (graph) and is imported by 76 packages. Updated 2019-07-22. Refresh now. Tools for package owners.