orm

package
v6.6.18+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 17, 2017 License: BSD-2-Clause Imports: 20 Imported by: 0

Documentation ¶

Index ¶

Constants ¶

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

Variables ¶

View Source 
var Tables = newTables()

Functions ¶

func Delete ¶ 

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

func Insert ¶ 

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

func Pagination ¶ 

func Pagination(values url.Values) func(*Query) (*Query, error)

Pagination is used with Query.Apply to set LIMIT and OFFSET from the URL values:

  • ?limit=10 - sets q.Limit(10), max limit is 1000.
  • ?page=5 - sets q.Offset((page - 1) * limit), max offset is 1000000.

func Q ¶ 

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

func Scan ¶ 

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

func Select ¶ 

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

func SetTableNameInflector ¶ 

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 URLFilters ¶ 

func URLFilters(urlValues url.Values) func(*Query) (*Query, error)

URLFilters is used with Query.Apply to add WHERE clauses from the URL values:

  • ?foo=bar - Where(`"foo" = 'bar'`)
  • ?foo=hello&foo=world - Where(`"foo" IN ('hello','world')`)
  • ?foo__exclude=bar - Where(`"foo" != 'bar'`)
  • ?foo__ieq=bar - Where(`"foo" ILIKE 'bar'`)
  • ?foo__match=bar - Where(`"foo" SIMILAR TO 'bar'`)
  • ?foo__gt=42 - Where(`"foo" > 42`)
  • ?foo__gte=42 - Where(`"foo" >= 42`)
  • ?foo__lt=42 - Where(`"foo" < 42`)
  • ?foo__lte=42 - Where(`"foo" <= 42`)

func Update ¶ 

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

Types ¶

type ColumnScanner ¶ 

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, b []byte) error
}

ColumnScanner is used to scan column values.

type CreateTableOptions ¶ 

type CreateTableOptions struct {
	Temp          bool
	IfNotExists   bool
	Varchar       int  // replaces PostgreSQL data type `text` with `varchar(n)`
	FKConstraints bool // whether to create foreign key constraints
}

type DB ¶ 

type DB interface {
	Model(model ...interface{}) *Query
	Select(model interface{}) error
	Insert(model ...interface{}) error
	Update(model ...interface{}) error
	Delete(model interface{}) error

	Exec(query interface{}, params ...interface{}) (Result, error)
	ExecOne(query interface{}, params ...interface{}) (Result, error)
	Query(coll, query interface{}, params ...interface{}) (Result, error)
	QueryOne(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 ¶ 

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

func (Discard) AddModel ¶ 

func (Discard) AddModel(_ ColumnScanner) error

func (Discard) AfterDelete ¶ 

func (Discard) AfterDelete(_ DB) error

func (Discard) AfterInsert ¶ 

func (Discard) AfterInsert(_ DB) error

func (Discard) AfterQuery ¶ 

func (Discard) AfterQuery(_ DB) error

func (Discard) AfterSelect ¶ 

func (Discard) AfterSelect(_ DB) error

func (Discard) AfterUpdate ¶ 

func (Discard) AfterUpdate(_ DB) error

func (Discard) BeforeDelete ¶ 

func (Discard) BeforeDelete(_ DB) error

func (Discard) BeforeInsert ¶ 

func (Discard) BeforeInsert(_ DB) error

func (Discard) BeforeUpdate ¶ 

func (Discard) BeforeUpdate(_ DB) error

func (Discard) Init ¶ 

func (Discard) Init() error

func (Discard) NewModel ¶ 

func (d Discard) NewModel() ColumnScanner

func (Discard) ScanColumn ¶ 

func (Discard) ScanColumn(colIdx int, colName string, b []byte) error

type DropTableOptions ¶ 

type DropTableOptions struct {
	IfExists bool
	Cascade  bool
}

type Field ¶ 

type Field struct {
	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
	// contains filtered or unexported fields
}

func (*Field) AppendValue ¶ 

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

func (*Field) Copy ¶ 

func (f *Field) Copy() *Field

func (*Field) HasFlag ¶ 

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

func (*Field) IsZero ¶ 

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

func (*Field) OmitZero ¶ 

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

func (*Field) ScanValue ¶ 

func (f *Field) ScanValue(strct reflect.Value, b []byte) error

func (*Field) SetFlag ¶ 

func (f *Field) SetFlag(flag uint8)

func (*Field) Value ¶ 

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

type FormatAppender ¶ 

type FormatAppender interface {
	AppendFormat([]byte, QueryFormatter) []byte
}

type Formatter ¶ 

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

func (Formatter) Append ¶ 

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

func (Formatter) AppendBytes ¶ 

func (f Formatter) AppendBytes(dst, src []byte, params ...interface{}) []byte

func (Formatter) FormatQuery ¶ 

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

func (*Formatter) SetParam ¶ 

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

func (Formatter) String ¶ 

func (f Formatter) String() string

func (*Formatter) WithParam ¶ 

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

type Method ¶ 

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

func (*Method) AppendValue ¶ 

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

func (*Method) Has ¶ 

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

func (*Method) Value ¶ 

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

type Model ¶ 

type Model interface {
	ColumnScanner

	Init() error

	// NewModel returns ColumnScanner that is used to scan columns
	// from the current row.
	NewModel() ColumnScanner

	// AddModel adds ColumnScanner to the Collection.
	AddModel(ColumnScanner) error

	AfterQuery(DB) error
	AfterSelect(DB) error

	BeforeInsert(DB) error
	AfterInsert(DB) error

	BeforeUpdate(DB) error
	AfterUpdate(DB) error

	BeforeDelete(DB) error
	AfterDelete(DB) error
}

func NewModel ¶ 

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

type Pager ¶ 

type Pager struct {
	Limit  int
	Offset int

	// Default max limit is 1000.
	MaxLimit int
	// Default max offset is 1000000.
	MaxOffset int
	// contains filtered or unexported fields
}

func NewPager ¶ 

func NewPager(values url.Values) *Pager

func (*Pager) GetLimit ¶ 

func (p *Pager) GetLimit() int

func (*Pager) GetOffset ¶ 

func (p *Pager) GetOffset() int

func (*Pager) GetPage ¶ 

func (p *Pager) GetPage() int

func (*Pager) Paginate ¶ 

func (p *Pager) Paginate(q *Query) (*Query, error)

func (*Pager) SetPage ¶ 

func (p *Pager) SetPage(page int)

func (*Pager) SetURLValues ¶ 

func (p *Pager) SetURLValues(values url.Values)

type Query ¶ 

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

func NewQuery ¶ 

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

func (*Query) AppendQuery ¶ 

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

func (*Query) Apply ¶ 

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

Apply calls the fn passing the Query as an argument.

func (*Query) Column ¶ 

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

Column adds column to the Query quoting it according to PostgreSQL rules. ColumnExpr can be used to bypass quoting restriction.

func (*Query) ColumnExpr ¶ 

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

ColumnExpr adds column expression to the Query.

func (*Query) Copy ¶ 

func (q *Query) Copy() *Query

Copy returns copy of the Query.

func (*Query) CopyFrom ¶ 

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

CopyFrom is an alias from DB.CopyFrom.

func (*Query) CopyTo ¶ 

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

CopyTo is an alias from DB.CopyTo.

func (*Query) Count ¶ 

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

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

func (*Query) CountEstimate ¶ 

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

CountEstimate uses EXPLAIN to get estimated number of rows matching 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 ¶ 

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

func (*Query) DB ¶ 

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

func (*Query) Delete ¶ 

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

Delete deletes the model.

func (*Query) DropTable ¶ 

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

func (*Query) Exec ¶ 

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

Exec is an alias for DB.Exec.

func (*Query) ExecOne ¶ 

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

ExecOne is an alias for DB.ExecOne.

func (*Query) First ¶ 

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 ¶ 

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

func (*Query) FormatQuery ¶ 

func (q *Query) FormatQuery(b []byte, query string, params ...interface{}) []byte

func (*Query) Group ¶ 

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

func (*Query) GroupExpr ¶ 

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

func (*Query) Having ¶ 

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

func (*Query) Insert ¶ 

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

Insert inserts the model.

func (*Query) Join ¶ 

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

func (*Query) Last ¶ 

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 ¶ 

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

func (*Query) Model ¶ 

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

func (*Query) New ¶ 

func (q *Query) New() *Query

New returns new zero Query binded to the current db and model.

func (*Query) Offset ¶ 

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

func (*Query) OnConflict ¶ 

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

func (*Query) Order ¶ 

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

Order adds sort order to the Query quoting column name. OrderExpr can be used to bypass quoting restriction.

func (*Query) OrderExpr ¶ 

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

Order adds sort order to the Query.

func (*Query) Query ¶ 

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

Query is an alias for DB.Query.

func (*Query) QueryOne ¶ 

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

QueryOne is an alias for DB.QueryOne.

func (*Query) Relation ¶ 

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

func (*Query) Returning ¶ 

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

func (*Query) Select ¶ 

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

Select selects the model.

func (*Query) SelectAndCount ¶ 

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

SelectAndCount runs Select and Count in two goroutines, waits for them to finish and returns the result.

func (*Query) SelectAndCountEstimate ¶ 

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

SelectAndCountEstimate runs Select and CountEstimate in two goroutines, waits for them to finish and returns the result.

func (*Query) SelectOrInsert ¶ 

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

SelectOrInsert selects the model inserting one if it does not exist.

func (*Query) Set ¶ 

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

func (*Query) Table ¶ 

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

func (*Query) TableExpr ¶ 

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

func (*Query) Update ¶ 

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

Update updates the model.

func (*Query) UpdateNotNull ¶ 

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

Update updates the model omitting null columns.

func (*Query) Where ¶ 

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

func (*Query) WhereGroup ¶ 

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 ¶ 

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

WhereIn is a shortcut for Where and pg.In to work with IN operator: 

WhereIn("id IN (?)", 1, 2, 3)

func (*Query) WhereOr ¶ 

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

func (*Query) WhereOrGroup ¶ 

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) WherePK ¶ 

func (q *Query) WherePK() *Query

func (*Query) With ¶ 

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

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

func (*Query) WrapWith ¶ 

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 ¶ 

type QueryAppender interface {
	Copy() QueryAppender
	Query() *Query
	AppendQuery(dst []byte) ([]byte, error)
}

type QueryFormatter ¶ 

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

type Relation ¶ 

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

	M2MTableName  types.Q
	M2MTableAlias types.Q
	BasePrefix    string
	JoinPrefix    string
}

type Result ¶ 

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
}

A Result summarizes an executed SQL command.

func CreateTable ¶ 

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

func DropTable ¶ 

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

type Table ¶ 

type Table struct {
	Type reflect.Type

	TypeName  string
	Name      types.Q
	Alias     types.Q
	ModelName string

	Fields     []*Field // PKs + DataFields
	PKs        []*Field
	DataFields []*Field
	FieldsMap  map[string]*Field

	Methods   map[string]*Method
	Relations map[string]*Relation
	// contains filtered or unexported fields
}

func (*Table) AddField ¶ 

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

func (*Table) AppendParam ¶ 

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

func (*Table) GetField ¶ 

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

func (*Table) HasField ¶ 

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

func (*Table) HasFlag ¶ 

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

func (*Table) SetFlag ¶ 

func (t *Table) SetFlag(flag uint8)

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.