actions

package
v1.4.0 Latest Latest
Warning

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

 Go to latest Published: Mar 20, 2021 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CopyActions 

type CopyActions struct {
	FindActions
}

CopyActions :

func (*CopyActions) Distinct 

func (act *CopyActions) Distinct() CopyStatement

Distinct :

func (*CopyActions) From 

func (act *CopyActions) From(values ...string) CopyStatement

From :

func (*CopyActions) GroupBy 

func (act *CopyActions) GroupBy(fields ...interface{}) CopyStatement

GroupBy :

func (*CopyActions) Having 

func (act *CopyActions) Having(fields ...interface{}) CopyStatement

Having :

func (*CopyActions) Limit 

func (act *CopyActions) Limit(num uint) CopyStatement

Limit :

func (*CopyActions) Offset 

func (act *CopyActions) Offset(num uint) CopyStatement

Offset :

func (*CopyActions) OrderBy 

func (act *CopyActions) OrderBy(fields ...interface{}) CopyStatement

OrderBy :

func (*CopyActions) Select 

func (act *CopyActions) Select(fields ...interface{}) CopyStatement

Select :

func (*CopyActions) Where 

func (act *CopyActions) Where(fields ...interface{}) CopyStatement

Where :

type CopyStatement 

type CopyStatement interface {
	Distinct() CopyStatement
	Select(fields ...interface{}) CopyStatement
	From(values ...string) CopyStatement
	Where(fields ...interface{}) CopyStatement
	Having(fields ...interface{}) CopyStatement
	GroupBy(fields ...interface{}) CopyStatement
	OrderBy(fields ...interface{}) CopyStatement
	Limit(num uint) CopyStatement
	Offset(num uint) CopyStatement
}

CopyStatement :

func Copy 

func Copy() CopyStatement

Copy :

type DeleteActions 

type DeleteActions struct {
	Database   string
	Table      string
	Conditions []interface{}
	Sorts      []interface{}
	Record     uint
}

DeleteActions :

func (*DeleteActions) Limit 

func (act *DeleteActions) Limit(num uint) DeleteStatement

Limit :

func (*DeleteActions) OrderBy 

func (act *DeleteActions) OrderBy(fields ...interface{}) DeleteStatement

OrderBy :

func (*DeleteActions) Where 

func (act *DeleteActions) Where(fields ...interface{}) DeleteStatement

Where :

type DeleteOneActions 

type DeleteOneActions struct {
	DeleteActions
}

DeleteOneActions :

func (*DeleteOneActions) Limit 

func (act *DeleteOneActions) Limit(num uint) DeleteOneStatement

Limit :

func (*DeleteOneActions) OrderBy 

func (act *DeleteOneActions) OrderBy(fields ...interface{}) DeleteOneStatement

OrderBy :

func (*DeleteOneActions) Where 

func (act *DeleteOneActions) Where(fields ...interface{}) DeleteOneStatement

Where :

type DeleteOneStatement 

type DeleteOneStatement interface {
	Where(fields ...interface{}) DeleteOneStatement
	OrderBy(fields ...interface{}) DeleteOneStatement
}

DeleteOneStatement :

func DeleteOne 

func DeleteOne() DeleteOneStatement

DeleteOne :

type DeleteStatement 

type DeleteStatement interface {
	Where(fields ...interface{}) DeleteStatement
	OrderBy(fields ...interface{}) DeleteStatement
	Limit(num uint) DeleteStatement
}

DeleteStatement :

func Delete 

func Delete() DeleteStatement

Delete :

type FindActions 

type FindActions struct {
	DistinctOn  bool
	Database    string
	Table       string
	Projections []interface{}
	IndexHints  string
	Conditions  primitive.Group
	Havings     primitive.Group
	GroupBys    []interface{}
	Sorts       []interface{}
	Skip        uint
	Count       uint
}

FindActions :

func (*FindActions) Distinct 

func (act *FindActions) Distinct() SelectStatement

Distinct :

func (*FindActions) From 

func (act *FindActions) From(values ...string) SelectStatement

From :

func (*FindActions) GroupBy 

func (act *FindActions) GroupBy(fields ...interface{}) SelectStatement

GroupBy :

func (*FindActions) Having 

func (act *FindActions) Having(fields ...interface{}) SelectStatement

Having :

func (*FindActions) Limit 

func (act *FindActions) Limit(num uint) SelectStatement

Limit :

func (*FindActions) Offset 

func (act *FindActions) Offset(num uint) SelectStatement

Offset :

func (*FindActions) OrderBy 

func (act *FindActions) OrderBy(fields ...interface{}) SelectStatement

OrderBy :

func (*FindActions) Select 

func (act *FindActions) Select(fields ...interface{}) SelectStatement

Select :

func (*FindActions) Where 

func (act *FindActions) Where(fields ...interface{}) SelectStatement

Where :

type FindOneActions 

type FindOneActions struct {
	FindActions
}

FindOneActions :

func (*FindOneActions) Distinct 

func (act *FindOneActions) Distinct() SelectOneStatement

Distinct :

func (*FindOneActions) From 

func (act *FindOneActions) From(values ...string) SelectOneStatement

From :

func (*FindOneActions) GroupBy 

func (act *FindOneActions) GroupBy(fields ...interface{}) SelectOneStatement

GroupBy :

func (*FindOneActions) Having 

func (act *FindOneActions) Having(fields ...interface{}) SelectOneStatement

Having :

func (*FindOneActions) OrderBy 

func (act *FindOneActions) OrderBy(fields ...interface{}) SelectOneStatement

OrderBy :

func (*FindOneActions) Select 

func (act *FindOneActions) Select(fields ...interface{}) SelectOneStatement

Select :

func (*FindOneActions) Where 

func (act *FindOneActions) Where(fields ...interface{}) SelectOneStatement

Where :

type PaginateActions 

type PaginateActions struct {
	FindActions
}

PaginateActions :

func (*PaginateActions) Distinct 

func (act *PaginateActions) Distinct() PaginateStatement

Distinct :

func (*PaginateActions) From 

func (act *PaginateActions) From(values ...string) PaginateStatement

From :

func (*PaginateActions) GroupBy 

func (act *PaginateActions) GroupBy(fields ...interface{}) PaginateStatement

GroupBy :

func (*PaginateActions) Having 

func (act *PaginateActions) Having(fields ...interface{}) PaginateStatement

Having :

func (*PaginateActions) Limit 

func (act *PaginateActions) Limit(num uint) PaginateStatement

Limit :

func (*PaginateActions) Offset 

func (act *PaginateActions) Offset(num uint) PaginateStatement

Offset :

func (*PaginateActions) OrderBy 

func (act *PaginateActions) OrderBy(fields ...interface{}) PaginateStatement

OrderBy :

func (*PaginateActions) Select 

func (act *PaginateActions) Select(fields ...interface{}) PaginateStatement

Select :

func (*PaginateActions) Where 

func (act *PaginateActions) Where(fields ...interface{}) PaginateStatement

Where :

type PaginateStatement 

type PaginateStatement interface {
	Distinct() PaginateStatement
	Select(fields ...interface{}) PaginateStatement
	From(values ...string) PaginateStatement
	Where(fields ...interface{}) PaginateStatement
	Having(fields ...interface{}) PaginateStatement
	GroupBy(fields ...interface{}) PaginateStatement
	OrderBy(fields ...interface{}) PaginateStatement
	Limit(num uint) PaginateStatement
	Offset(num uint) PaginateStatement
}

PaginateStatement :

func Paginate 

func Paginate() PaginateStatement

Paginate :

type SelectOneStatement 

type SelectOneStatement interface {
	Distinct() SelectOneStatement
	Select(fields ...interface{}) SelectOneStatement
	From(values ...string) SelectOneStatement
	Where(fields ...interface{}) SelectOneStatement
	Having(fields ...interface{}) SelectOneStatement
	GroupBy(fields ...interface{}) SelectOneStatement
	OrderBy(fields ...interface{}) SelectOneStatement
}

SelectOneStatement :

func FindOne 

func FindOne() SelectOneStatement

FindOne :

type SelectStatement 

type SelectStatement interface {
	Distinct() SelectStatement
	Select(fields ...interface{}) SelectStatement
	From(values ...string) SelectStatement
	Where(fields ...interface{}) SelectStatement
	Having(fields ...interface{}) SelectStatement
	GroupBy(fields ...interface{}) SelectStatement
	OrderBy(fields ...interface{}) SelectStatement
	Limit(num uint) SelectStatement
	Offset(num uint) SelectStatement
}

SelectStatement :

func Find 

func Find() SelectStatement

Find :

type UpdateActions 

type UpdateActions struct {
	Database   string
	Table      string
	Conditions []interface{}
	Values     []primitive.KV
	Sorts      []interface{}
	Record     uint
}

UpdateActions :

func (*UpdateActions) Limit 

func (act *UpdateActions) Limit(num uint) UpdateStatement

Limit :

func (*UpdateActions) OrderBy 

func (act *UpdateActions) OrderBy(fields ...interface{}) UpdateStatement

OrderBy :

func (*UpdateActions) Set 

func (act *UpdateActions) Set(values ...primitive.KV) UpdateStatement

Set :

func (*UpdateActions) Where 

func (act *UpdateActions) Where(fields ...interface{}) UpdateStatement

Where :

type UpdateOneActions 

type UpdateOneActions struct {
	UpdateActions
}

UpdateOneActions :

func (*UpdateOneActions) OrderBy 

func (act *UpdateOneActions) OrderBy(fields ...interface{}) UpdateOneStatement

OrderBy :

func (*UpdateOneActions) Set 

func (act *UpdateOneActions) Set(values ...primitive.KV) UpdateOneStatement

Set :

func (*UpdateOneActions) Where 

func (act *UpdateOneActions) Where(fields ...interface{}) UpdateOneStatement

Where :

type UpdateOneStatement 

type UpdateOneStatement interface {
	Where(fields ...interface{}) UpdateOneStatement
	Set(values ...primitive.KV) UpdateOneStatement
	OrderBy(fields ...interface{}) UpdateOneStatement
}

UpdateOneStatement :

func UpdateOne 

func UpdateOne() UpdateOneStatement

UpdateOne :

type UpdateStatement 

type UpdateStatement interface {
	Where(fields ...interface{}) UpdateStatement
	Set(values ...primitive.KV) UpdateStatement
	OrderBy(fields ...interface{}) UpdateStatement
	Limit(num uint) UpdateStatement
}

UpdateStatement :

func Update 

func Update() UpdateStatement

Update :

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.