aorm

package module
v1.9.2-0...-397750e Latest Latest
Warning

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

 Go to latest Published: Apr 15, 2020 License: MIT Imports: 30 Imported by: 38

README

AORM

The fantastic Advanced ORM library for Golang, aims to be developer friendly.

This is a fork of GORM with improved performance and many other features.

go report card wercker status Open Collective Backer Open Collective Sponsor MIT license GoDoc

Overview

  • Full-Featured ORM (almost)
  • Associations (Has One, Has Many, Belongs To, Many To Many, Polymorphism)
  • Hooks (Before/After Create/Save/Update/Delete/Find)
  • Preloading (eager loading)
  • Transactions
  • Composite Primary Key
  • SQL Builder
  • Auto Migrations
  • Logger
  • Extendable, write Plugins based on GORM callbacks
  • Every feature comes with tests
  • Developer Friendly
  • NEW: Inline model loader and auto loader
  • NEW: Null values scaner without Nullable Field
  • NEW: Log callbacks
  • NEW: After scanner callbacks
  • NEW: Binary ID (using bid.BID)
  • NEW: Index/Unique Index withe WHERE clause
  • NEW: Raw args binder
  • NEW: Custom arg binder by dialect
  • NEW: Custom arg valuer by dialect
  • NEW: POLYMORPHIC_VALUE tag: sql:"POLYMORPHIC_VALUE:user" or singular and plural: sql:"POLYMORPHIC_VALUE:user,users"
  • NEW: Dry Run db.DryRun().First(&user)
  • NEW: Model Struct Api: aorm.StructOf(&User{})
  • NEW: Model Struct interface: aorm.InstaceOf(&User{})
  • NEW: ID Api: aorm.IdOf(&User{ID:1})
  • NEW: Get executed query and args fmt.Println(db.First(&user).Query) or fmt.Println(db.DryRun().First(&user).Query)
  • NEW: Readonly fields with select query
  • NEW: Args and Query API db.First(&user, aorm.Query{"name = ?", []interface{}{"joe"}}) or your type implements aorm.Clauser
  • NEW: Money type
  • NEW: Dynamic table namer
  • NEW: and more other changes...

Installation

WINDOWS NOTE: run these commands inside CygWin or Git Bash.

go get -u github.com/moisespsena-go/aorm
cd $GOPATH/github.com/moisespsena-go/aorm
go generate
GO DEP

If uses dep for manage your dependencies, runs:

cd YOUR_PROJECT_DIR
dep ensure -add github.com/moisespsena-go/aorm
cd vendor/github.com/moisespsena-go/aorm
go generate

Getting Started

Contributing

You can help to deliver a better GORM, check out things you can do

License

© Moises P. Sena, 2018~time.Now

Released under the MIT License

Documentation

Index

Examples

Constants

View Source 
const (
	AuditedFieldCreatedByID = "CreatedByID"
	AuditedFieldUpdatedByID = "UpdatedByID"

	AuditedColumnCreatedByID = "created_by_id"
	AuditedColumnUpdatedByID = "updated_by_id"

	AuditedFieldCreatedAt = "CreatedAt"
	AuditedFieldUpdatedAt = "UpdatedAt"

	AuditedColumnCreatedAt = "created_at"
	AuditedColumnUpdatedAt = "updated_at"
)
View Source 
const (
	OptSkipPreload = "aorm:skip_preload"
	OptAutoPreload = "aorm:auto_preload"
)
View Source 
const (
	DefaultQuoter = QuoteRuner('`')
	QuoteCharS    = string(DefaultQuoter)
)
View Source 
const (
	LOG_CREATE = "create"
	LOG_READ   = "read"
	LOG_UPDATE = "update"
	LOG_DELETE = "delete"
	LOG_QUERY  = "query"
	LOG_EXEC   = "exec"
)
View Source 
const (
	SoftDeleteFieldDeletedByID = "DeletedByID"
	SoftDeleteFieldDeletedAt   = "DeletedAt"

	SoftDeletedColumnDeletedByID = "deleted_by_id"
	SoftDeleteColumnDeletedAt    = "deleted_at"
)
View Source 
const (
	TimestampFieldCreatedAt = "CreatedAt"
	TimestampFieldUpdatedAt = "UpdatedAt"

	TimestampColumnCreatedAt = "created_at"
	TimestampColumnUpdatedAt = "updated_at"
)
View Source 
const (
	CbGenId = ""
)
View Source 
const (
	StoreBlankField = "aorm:store_blank_field"
)

Variables

View Source 
var (
	AuditedFieldsByID = []string{
		AuditedFieldCreatedByID,
		AuditedFieldUpdatedByID,
	}

	AuditedFieldsAt = append([]string{
		AuditedFieldCreatedAt,
		AuditedFieldUpdatedAt,
	}, TimestampFields...)

	AuditedColumnsByID = []string{
		AuditedColumnCreatedByID,
		AuditedColumnUpdatedByID,
	}

	AuditedColumnsAt = append([]string{
		AuditedColumnCreatedAt,
		AuditedColumnUpdatedAt,
	}, TimestampColumns...)

	AuditedFields  = append(AuditedFieldsByID, AuditedFieldsAt...)
	AuditedColumns = append(AuditedColumnsByID, AuditedColumnsAt...)
)
View Source 
var (
	// ErrRecordNotFound record not found error, happens when haven'T find any matched data when looking up with a struct
	ErrRecordNotFound = errors.New("record not found")
	// ErrInvalidSQL invalid SQL error, happens when you passed invalid SQL
	ErrInvalidSQL = errors.New("invalid SQL")
	// ErrInvalidTransaction invalid transaction when you are trying to `Commit` or `Rollback`
	ErrInvalidTransaction = errors.New("no valid transaction")
	// ErrCantStartTransaction can'T start transaction when you are trying to start one with `Begin`
	ErrCantStartTransaction = errors.New("can'T start transaction")
	// ErrUnaddressable unaddressable value
	ErrUnaddressable = errors.New("using unaddressable value")
	// ErrSingleUpdateKey single UPDATE require primary key value
	ErrSingleUpdateKey = errors.New("Single UPDATE require primary key value.")
)
View Source 
var (
	SoftDeleteFields = []string{
		SoftDeleteFieldDeletedByID,
		SoftDeleteFieldDeletedAt,
	}

	AuditedSDFields = append(append([]string{}, AuditedFields...), SoftDeleteFields...)
)
View Source 
var (
	SqlConvertAssign     = sql.GithubComMoisespsenaGoAormConvertAssign
	SqlConvertAssignRows = sql.GithubComMoisespsenaGoAormConvertAssignRows
)
View Source 
var (
	TimestampFields = []string{
		TimestampFieldCreatedAt,
		TimestampFieldUpdatedAt,
	}

	TimestampColumns = []string{
		TimestampColumnCreatedAt,
		TimestampColumnUpdatedAt,
	}
)
View Source 
var DefaultCallback = &Callback{}

DefaultCallback default callbacks defined by gorm

View Source 
var DefaultLogger = &ScopeLoggers{}
View Source 
var DefaultTableNameHandler = func(ctx context.Context, singular bool, modelStruct *ModelStruct) (tableName string) {
	if singular {
		return modelStruct.SingularTableName
	}
	return modelStruct.PluralTableName
}

DefaultTableNameHandler default table name handler

View Source 
var LogFormatter = func(values ...interface{}) (messages []interface{}) {
	if len(values) > 1 {
		var (
			sql             string
			formattedValues []string
			level           = values[0]
			currentTime     = "\n\033[33m[" + NowFunc().Format("2006-01-02 15:04:05") + "]\033[0m"
			source          = fmt.Sprintf("\033[35m(%v)\033[0m", values[1])
		)

		messages = []interface{}{source, currentTime}

		if level == "sql" {

			messages = append(messages, fmt.Sprintf(" \033[36;1m[%.2fms]\033[0m ", float64(values[2].(time.Duration).Nanoseconds()/1e4)/100.0))

			for _, value := range values[4].([]interface{}) {
				indirectValue := reflect.Indirect(reflect.ValueOf(value))
				if indirectValue.IsValid() {
					value = indirectValue.Interface()
					if t, ok := value.(time.Time); ok {
						formattedValues = append(formattedValues, fmt.Sprintf("'%v'", t.Format("2006-01-02 15:04:05")))
					} else if b, ok := value.([]byte); ok {
						if str := string(b); isPrintable(str) {
							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", str))
						} else {
							formattedValues = append(formattedValues, "'<binary>'")
						}
					} else if r, ok := value.(driver.Valuer); ok {
						if value, err := r.Value(); err == nil && value != nil {
							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", value))
						} else {
							formattedValues = append(formattedValues, "NULL")
						}
					} else {
						formattedValues = append(formattedValues, fmt.Sprintf("'%v'", value))
					}
				} else {
					formattedValues = append(formattedValues, "NULL")
				}
			}

			if numericPlaceHolderRegexp.MatchString(values[3].(string)) {
				sql = values[3].(string)
				for index, value := range formattedValues {
					placeholder := fmt.Sprintf(`\$%d([^\d]|$)`, index+1)
					sql = regexp.MustCompile(placeholder).ReplaceAllString(sql, value+"$1")
				}
			} else {
				formattedValuesLength := len(formattedValues)
				for index, value := range sqlRegexp.Split(values[3].(string), -1) {
					sql += value
					if index < formattedValuesLength {
						sql += formattedValues[index]
					}
				}
			}

			messages = append(messages, sql)
			messages = append(messages, fmt.Sprintf(" \n\033[36;31m[%v]\033[0m ", strconv.FormatInt(values[5].(int64), 10)+" rows affected or returned "))
		} else {
			messages = append(messages, "\033[31;1m")
			messages = append(messages, values[2:]...)
			messages = append(messages, "\033[0m")
		}

		return
	}

	return values
}
View Source 
var NowFunc = func() time.Time {
	return time.Now()
}

NowFunc returns current time, this function is exported in order to be able to give the flexibility to the developer to customize it according to their needs, e.g: 

aorm.NowFunc = func() time.Time {
  return time.Now().UTC()
}
View Source 
var ParseFieldStructForDialect = func(field *FieldStructure, dialect Dialector) (fieldValue reflect.Value, sqlType string, size int, additionalType string) {
	// Get redirected field type
	var (
		reflectType = field.Type
		dataType    = field.TagSettings["TYPE"]
	)

	for reflectType.Kind() == reflect.Ptr {
		reflectType = reflectType.Elem()
	}

	if dataType != "" {
		switch reflectType.Kind() {
		case reflect.String:
			dataType = AbbrToTextType(dataType)
		}
	}

	if dataType == "" && field.Assigner != nil {
		dataType = field.Assigner.SQLType(dialect)
	}

	fieldValue = reflect.Indirect(reflect.New(reflectType))

	if dataTyper, ok := fieldValue.Interface().(DbDataTyper); ok {
		dataType = dataTyper.AormDataType(dialect)
	}

	if dataType == "" {
		var getScannerValue func(reflect.Value)
		getScannerValue = func(value reflect.Value) {
			fieldValue = value
			if _, isScanner := reflect.New(fieldValue.Type()).Interface().(sql.Scanner); isScanner && fieldValue.Kind() == reflect.Struct {
				getScannerValue(fieldValue.Field(0))
			}
		}
		getScannerValue(fieldValue)
	}

	if num, ok := field.TagSettings["SIZE"]; ok {
		size, _ = strconv.Atoi(num)
	} else if sizer, ok := field.Assigner.(SQLSizer); ok {
		size = sizer.SQLSize(dialect)
	} else {
		size = 255
	}

	additionalType = field.TagSettings["NOT NULL"] + " " + field.TagSettings["UNIQUE"]
	if value, ok := field.TagSettings["DEFAULT"]; ok {

		if value != "DEFAULT" {
			additionalType = additionalType + " DEFAULT " + value
		}
	}

	return fieldValue, dataType, size, strings.TrimSpace(additionalType)
}

ParseFieldStructForDialect get field's sql data type

View Source 
var StructFieldMethodCallbacks = NewStructFieldMethodCallbacksRegistrator()

StructFieldMethodCallbacks is a default registrator for model fields callbacks where the field type is a struct and have a callback method. Default methods callbacks: AfterScan: Call method `AfterScanMethodCallback` after scan field from sql row.

Functions

func AbbrToTextType 

func AbbrToTextType(abbr string) string

func AcceptTypeForModelStruct 

func AcceptTypeForModelStruct(typ interface{}) (ok bool)

func AcceptableTypeForModelStructInterface 

func AcceptableTypeForModelStructInterface(i interface{}) (typ reflect.Type)

func AfterScanMethodCallback 

func AfterScanMethodCallback(_ *Method, method interface{}, field *Field, scope *Scope)
Example 
package main

import ()

func main() {
	println(`
package main

import (
	"reflect"
	"github.com/moisespsena-go/aorm"
	"database/sql/driver"
	_ "github.com/moisespsena-go/aorm/dialects/sqlite"
	"strconv"
	"strings"
)

type Media struct {
	Name      string
	baseUrl   *string
	modelType reflect.Type
	model interface {
		GetID() int
	}
	fieldName *string
}

func (image *Media) Scan(value interface{}) error {
	image.Name = string(value.([]byte))
	return nil
}

func (image *Media) Value() (driver.Value, error) {
	return image.Name, nil
}

func (image *Media) AfterScan(scope *aorm.Scope, field *aorm.Field) {
	image.fieldName, image.model = &field.StructField.Name, scope.Val.(interface {
		GetID() int
	})
	baseUrl, _ := scope.DB().Get("base_url")
	image.baseUrl = baseUrl.(*string)
	image.modelType = reflect.TypeOf(scope.Val)
	for image.modelType.Kind() == reflect.Ptr {
		image.modelType = image.modelType.Elem()
	}
}

func (image *Media) URL() string {
	return strings.Join([]string{*image.baseUrl, image.modelType.Name(), strconv.Itoa(image.model.GetID()),
		*image.fieldName, image.Name}, "/")
}

type User struct {
	BID        int
	MainImage Media
}

func (user *User) GetID() int {
	return user.BID
}

func main() {
	// register media type
	aorm.StructFieldMethodCallbacks.RegisterFieldType(&Media{})

	db, err := aorm.Open("sqlite3", "db.db")
	if err != nil {
		panic(err)
	}

	db.AutoMigrate(&User{})

	baseUrl := "http://example.com/media"
	db = db.Set("base_url", &baseUrl)

	var model User
	db_ := db.Where("id = ?", 1).First(&model)
	if db_.RecordNotFound() {
		db.Save(&User{MainImage: Media{Name: "picture.jpg"}})
		err = db.Where("id = ?", 1).First(&model).error
		if err != nil {
			panic(err)
		}
	} else if db_.error != nil {
		panic(db_.error)
	}

	println("Media URL:", model.MainImage.URL())
}
`)
}

Output:

func BindVar 

func BindVar(dialect Dialector, assigner Assigner, value interface{}, replacement string) string

func BindVarStructure 

func BindVarStructure(dialect Dialector, field *FieldStructure, replacement string) string

func Each 

func Each(it RecordsIterator, cb func(i int, r interface{}) error) (err error)

func ErrorByType 

func ErrorByType(expected reflect.Type, err ...error) (theError error)

func ExcludeTypeForModelStruct 

func ExcludeTypeForModelStruct(typ ...interface{})

func IDValueRawConverterRegister 

func IDValueRawConverterRegister(typ reflect.Type, converter IDValueRawConverter)

func IdStringTo 

func IdStringTo(id string, value interface{}) error

IdStringTo parses id from strign and set it to model value

func InID 

func InID(id ...ID) *idSliceScoper

func InIDNamedTable 

func InIDNamedTable(tableName string, id ...ID) *idSliceNamedTable

func InlinePreloadCallback 

func InlinePreloadCallback(scope *Scope)

func InlinePreloadFieldsKeyOf 

func InlinePreloadFieldsKeyOf(value interface{}) string

func IsBlank 

func IsBlank(value reflect.Value) bool

func IsByteArrayOrSlice 

func IsByteArrayOrSlice(value reflect.Value) bool

IsByteArrayOrSlice returns true of the reflected value is an array or slice

func IsDuplicateUniqueIndexError 

func IsDuplicateUniqueIndexError(err ...error) bool

func IsError 

func IsError(expected error, err ...error) (is bool)

func IsErrorTyp 

func IsErrorTyp(expected reflect.Type, err ...error) (is bool)

func IsManyResult 

func IsManyResult(dst interface{}) (many bool)

func IsQueryError 

func IsQueryError(err ...error) bool

func IsRecordNotFoundError 

func IsRecordNotFoundError(err error) bool

IsRecordNotFoundError returns current error has record not found error or not

func Iterate 

func Iterate(it RecordsIterator) (err error)

func M2MNameOf 

func M2MNameOf(a reflect.Type, b reflect.Type) (prefix, name string)

func M2MNameOfString 

func M2MNameOfString(aName, bName string) (prefix, name string)

func OpenIterate 

func OpenIterate(opener RecordsIteratorOpener) (err error)

func PathsFromQuery 

func PathsFromQuery(query string) (paths []string)

func Quote 

func Quote(q Quoter, key string) string

Quote quotes field name to avoid SQL parsing exceptions by using a reserved word as a field name

func QuoteConvert 

func QuoteConvert(q Quoter, s string) string

QuoteConvert converts all characters equals QuoteChar in string to quote char

func QuoteConvertChar 

func QuoteConvertChar(q Quoter, fromChar string, s string) string

QuoteConvertChar converts all characters equals fromChar in string to quote char

func Register 

func Register(assigner ...Assigner)

func RegisterDialect 

func RegisterDialect(name string, dialect Dialector)

RegisterDialect register new dialect

func SenderOf 

func SenderOf(value reflect.Value) (send func(el reflect.Value))

func SetIdCallback 

func SetIdCallback(scope *Scope)

func SetNonZero 

func SetNonZero(rvalue reflect.Value, value interface{})

func SetZero 

func SetZero(rvalue reflect.Value)

func StructTypeOf 

func StructTypeOf(value reflect.Type) (typ reflect.Type, many, ptr bool)

func StructTypeOfInterface 

func StructTypeOfInterface(value interface{}) (typ reflect.Type, many, ptr bool)

func ToDBName 

func ToDBName(name string) string

ToDBName convert string to db name

func TupleQueryArgs 

func TupleQueryArgs(argCount int) (query string)

TupleQueryArgs create tuple args from argCount

func ValuerFunc 

func ValuerFunc(f func() (driver.Value, error)) driver.Valuer

func WalkErr 

func WalkErr(cb func(err error) (stop bool), errs ...error) (stop bool)

func ZeroIdOf 

func ZeroIdOf(value interface{}) bool

ZeroIdOf returns if ID of model value is zero

Types

type AfterInlinePreloadScanner 

type AfterInlinePreloadScanner interface {
	AormAfterInlinePreloadScan(ip *InlinePreloader, recorde, value interface{})
}

type Alias 

type Alias struct {
	Expr string
	Name string
}

type AormNonFieldStructor 

type AormNonFieldStructor interface {
	AormNonFieldStructor()
}

type ArgBinder 

type ArgBinder interface {
	DbBindVar(dialect Dialector, argVar string) string
}

type AssignArgBinder 

type AssignArgBinder interface {
	Assigner
	ArgBinder
}

type Assigner 

type Assigner interface {
	Valuer(dialect Dialector, value interface{}) driver.Valuer
	Scaner(dialect Dialector, dest reflect.Value) Scanner
	SQLType(dialect Dialector) string
	Type() reflect.Type
}

type AssignerRegistrator 

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

func Assigners 

func Assigners() *AssignerRegistrator

func (*AssignerRegistrator) ApplyToDialect 

func (a *AssignerRegistrator) ApplyToDialect(dialect Dialector)

func (*AssignerRegistrator) Get 

func (a *AssignerRegistrator) Get(typ reflect.Type) (assigner Assigner)

func (*AssignerRegistrator) Has 

func (a *AssignerRegistrator) Has(typ reflect.Type) (ok bool)

func (*AssignerRegistrator) Of 

func (a *AssignerRegistrator) Of(value interface{}) (assigner Assigner)

func (*AssignerRegistrator) Register 

func (a *AssignerRegistrator) Register(assigners ...Assigner)

type Association 

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

Association Mode contains some helper methods to handle relationship things easily.

func (*Association) Append 

func (this *Association) Append(values ...interface{}) *Association

Append append new associations for many2many, has_many, replace current association for has_one, belongs_to

func (*Association) Clear 

func (this *Association) Clear() *Association

Clear remove relationship between source & current associations, won'T delete those associations

func (*Association) Count 

func (this *Association) Count() int

Count return the count of current associations

func (*Association) Delete 

func (this *Association) Delete(values ...interface{}) *Association

Delete remove relationship between source & passed arguments, but won'T delete those arguments

func (*Association) Error 

func (this *Association) Error() error

func (*Association) Find 

func (this *Association) Find(value interface{}) *Association

Find find out all related associations

func (*Association) HasError 

func (this *Association) HasError() bool

func (*Association) Replace 

func (this *Association) Replace(values ...interface{}) *Association

Replace replace current associations with new one

type Audited 

type Audited struct {
	CreatedByID bid.BID
	UpdatedByID bid.BID
	Timestamps
}

func (*Audited) GetCreatedBy 

func (a *Audited) GetCreatedBy() IDValuer

func (*Audited) GetUpdatedBy 

func (a *Audited) GetUpdatedBy() IDValuer

func (*Audited) SetCreatedBy 

func (a *Audited) SetCreatedBy(value IDValuer)

func (*Audited) SetUpdatedBy 

func (a *Audited) SetUpdatedBy(value IDValuer)

type AuditedModel 

type AuditedModel struct {
	Model
	Audited
}

type AuditedSD 

type AuditedSD struct {
	Audited
	SoftDeleteAudited
}

type AuditedSDModel 

type AuditedSDModel struct {
	Model
	AuditedSD
}

type Auditor 

type Auditor interface {
	Timestamper
	SetCreatedBy(createdBy IDValuer)
	GetCreatedBy() IDValuer
	SetUpdatedBy(updatedBy IDValuer)
	GetUpdatedBy() IDValuer
}

type BIDAssigner 

type BIDAssigner struct {
}

func (BIDAssigner) DbBindVar 

func (a BIDAssigner) DbBindVar(dialect Dialector, argVar string) string

func (BIDAssigner) FromRaw 

func (BIDAssigner) FromRaw(raw interface{}) IDValuer

func (BIDAssigner) SQLSize 

func (BIDAssigner) SQLSize(_ Dialector) int

func (BIDAssigner) SQLType 

func (BIDAssigner) SQLType(dialect Dialector) string

func (BIDAssigner) Scaner 

func (BIDAssigner) Scaner(_ Dialector, dest reflect.Value) Scanner

func (BIDAssigner) ToRaw 

func (BIDAssigner) ToRaw(value IDValuer) interface{}

func (BIDAssigner) Type 

func (BIDAssigner) Type() reflect.Type

func (BIDAssigner) Valuer 

func (BIDAssigner) Valuer(dialect Dialector, value interface{}) driver.Valuer

type BIDIdValuer 

type BIDIdValuer BytesId

func (BIDIdValuer) Bytes 

func (this BIDIdValuer) Bytes() []byte

func (BIDIdValuer) IsZero 

func (this BIDIdValuer) IsZero() bool

func (BIDIdValuer) ParseBytes 

func (BIDIdValuer) ParseBytes(b []byte) (IDValuer, error)

func (BIDIdValuer) ParseString 

func (BIDIdValuer) ParseString(s string) (_ IDValuer, err error)

func (BIDIdValuer) Raw 

func (this BIDIdValuer) Raw() interface{}

func (BIDIdValuer) String 

func (this BIDIdValuer) String() string

type BytesId 

type BytesId []byte

func (BytesId) Bytes 

func (this BytesId) Bytes() []byte

func (BytesId) IsZero 

func (this BytesId) IsZero() bool

func (BytesId) ParseBytes 

func (BytesId) ParseBytes(b []byte) (IDValuer, error)

func (BytesId) ParseString 

func (BytesId) ParseString(s string) (_ IDValuer, err error)

func (BytesId) Raw 

func (this BytesId) Raw() interface{}

func (BytesId) String 

func (this BytesId) String() string

type BytesParser 

type BytesParser interface {
	ParseBytes(b []byte) error
}

type Callback 

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

Callback is a struct that contains all CRUD callbacks 

Field `creates` contains callbacks will be call when creating object
Field `updates` contains callbacks will be call when updating object
Field `deletes` contains callbacks will be call when deleting object
Field `queries` contains callbacks will be call when querying object with query methods like Find, First, Related, Association...
Field `rowQueries` contains callbacks will be call when querying object with Row, Rows...
Field `processors` contains all callback processors, will be used to generate above callbacks in order

func (*Callback) Create 

func (c *Callback) Create() *CallbackProcessor

Create could be used to register callbacks for creating object 

db.Callback().Create().After("aorm:create").Register("plugin:run_after_create", func(*Scope) {
  // business logic
  ...

  // set error if some thing wrong happened, will rollback the creating
  scope.Err(errors.New("error"))
})

func (*Callback) Delete 

func (c *Callback) Delete() *CallbackProcessor

Delete could be used to register callbacks for deleting object, refer `Create` for usage

func (*Callback) Query 

func (c *Callback) Query() *CallbackProcessor

Query could be used to register callbacks for querying objects with query methods like `Find`, `First`, `Related`, `Association`... Refer `Create` for usage

func (*Callback) RowQuery 

func (c *Callback) RowQuery() *CallbackProcessor

RowQuery could be used to register callbacks for querying objects with `Row`, `Rows`, refer `Create` for usage

func (*Callback) Update 

func (c *Callback) Update() *CallbackProcessor

Update could be used to register callbacks for updating object, refer `Create` for usage

type CallbackProcessor 

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

CallbackProcessor contains callback informations

func (*CallbackProcessor) After 

func (cp *CallbackProcessor) After(callbackName string) *CallbackProcessor

After insert a new callback after callback `callbackName`, refer `Callbacks.Create`

func (*CallbackProcessor) Before 

func (cp *CallbackProcessor) Before(callbackName string) *CallbackProcessor

Before insert a new callback before callback `callbackName`, refer `Callbacks.Create`

func (*CallbackProcessor) Get 

func (cp *CallbackProcessor) Get(callbackName string) (callback func(scope *Scope))

Get registered callback 

db.Callback().Create().Get("aorm:create")

func (*CallbackProcessor) Register 

func (cp *CallbackProcessor) Register(callbackName string, callback func(scope *Scope))

Register a new callback, refer `Callbacks.Create`

func (*CallbackProcessor) Remove 

func (cp *CallbackProcessor) Remove(callbackName string)

Remove a registered callback 

db.Callback().Create().Remove("aorm:update_time_stamp_when_create")

func (*CallbackProcessor) Replace 

func (cp *CallbackProcessor) Replace(callbackName string, callback func(scope *Scope))

Replace a registered callback with new callback 

    db.Callback().Create().Replace("aorm:update_time_stamp_when_create", func(*Scope) {
		   scope.SetColumn("Created", now)
		   scope.SetColumn("Updated", now)
    })

type Clause 

type Clause struct {
	Query interface{}
	Args  []interface{}
}

func (*Clause) BuildCondition 

func (clause *Clause) BuildCondition(scope *Scope, include bool) (result Query)

type ClauseScoper 

type ClauseScoper interface {
	TableNamer
	ToVarsAppender
	QuotedTableName() string
	Struct() *ModelStruct
	Instance() *Instance
	ScopeOfField(fieldName string) *Scope
}

type Clauser 

type Clauser interface {
	Clause(scope *Scope) (result Query)
}

type ColumnDismissibleTypeScaner 

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

type ColumnDismissibleTypeScanerHandler 

type ColumnDismissibleTypeScanerHandler interface {
	Scaner(scope *Scope, record interface{}, column string) sql.Scanner
}

type Conditions 

type Conditions struct {
	Args Vars
	// contains filtered or unexported fields
}

func NewConditions 

func NewConditions() *Conditions

func (*Conditions) MergeTo 

func (this *Conditions) MergeTo(db *DB) *DB

func (*Conditions) Not 

func (this *Conditions) Not(query interface{}, values ...interface{}) *Conditions

func (*Conditions) Or 

func (this *Conditions) Or(query interface{}, values ...interface{}) *Conditions

func (*Conditions) Prepare 

func (this *Conditions) Prepare(cb func(c *Conditions, query interface{}, args []interface{}, replace func(query interface{}, args ...interface{})))

func (*Conditions) Where 

func (this *Conditions) Where(query interface{}, values ...interface{}) *Conditions

func (*Conditions) WhereClause 

func (this *Conditions) WhereClause(scope *Scope) (result Query)

type DB 

type DB struct {
	Val          interface{}
	Error        error
	RowsAffected int64

	Context context.Context

	Query *Query
	// contains filtered or unexported fields
}

DB contains information for current db connection

func CreateFakeDB 

func CreateFakeDB(dialect string) (db *DB)

CreateFakeDB create a new fake db with dialect

func FakeDB 

func FakeDB(dialect string) (db *DB)

FakeDB get or create a new fake db with dialect

func NewDB 

func NewDB(dialect ...Dialector) (db *DB)

func Open 

func Open(dialect string, args ...interface{}) (db *DB, err error)

Open initialize a new db connection, need to import driver first, e.g: 

import _ "github.com/go-sql-driver/mysql"
func main() {
  db, err := aorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")
}

AORM has wrapped some drivers, for easier to remember driver's import path, so you could import the mysql driver with 

import _ "github.com/moisespsena-go/aorm/dialects/mysql"
// import _ "github.com/moisespsena-go/aorm/dialects/postgres"
// import _ "github.com/moisespsena-go/aorm/dialects/sqlite"
// import _ "github.com/moisespsena-go/aorm/dialects/mssql"

func (*DB) AddError 

func (s *DB) AddError(err error) error

AddError add error to the db

func (*DB) AddForeignKey 

func (s *DB) AddForeignKey(field string, dest string, onDelete string, onUpdate string) *DB

AddForeignKey Add foreign key to the given scope, e.g: 

db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")

func (*DB) AddIndex 

func (s *DB) AddIndex(indexName string, columns ...string) *DB

AddIndex add index for columns with given name

func (*DB) AddUniqueIndex 

func (s *DB) AddUniqueIndex(indexName string, columns ...string) *DB

AddUniqueIndex add unique index for columns with given name

func (*DB) Assign 

func (s *DB) Assign(attrs ...interface{}) *DB

Assigner assign result with argument regardless it is found or not with `FirstOrInit` https://jinzhu.github.io/gorm/crud.html#firstorinit or `FirstOrCreate` https://jinzhu.github.io/gorm/crud.html#firstorcreate

func (*DB) Association 

func (s *DB) Association(relatedFieldName string) *Association

Association start `Association Mode` to handler relations things easir in that mode, refer: https://jinzhu.github.io/gorm/associations.html#association-mode

func (*DB) Attrs 

func (s *DB) Attrs(attrs ...interface{}) *DB

Attrs initialize struct with argument if record not found with `FirstOrInit` https://jinzhu.github.io/gorm/crud.html#firstorinit or `FirstOrCreate` https://jinzhu.github.io/gorm/crud.html#firstorcreate

func (*DB) AutoInlinePreload 

func (s *DB) AutoInlinePreload(value interface{}) *DB

AutoInlinePreload preload associations

func (*DB) AutoMigrate 

func (s *DB) AutoMigrate(values ...interface{}) *DB

AutoMigrate run auto migration for given models, will only add missing fields, won'T delete/change current data

func (*DB) Begin 

func (s *DB) Begin() *DB

Begin begin a transaction

func (*DB) BlockGlobalUpdate 

func (s *DB) BlockGlobalUpdate(enable bool) *DB

BlockGlobalUpdate if true, generates an error on update/delete without where clause. This is to prevent eventual error with empty objects updates/deletions

func (*DB) Callback 

func (s *DB) Callback() *Callback

Callback return `Callbacks` container, you could add/change/delete callbacks with it 

db.Callback().Create().Register("update_created_at", updateCreated)

Refer https://jinzhu.github.io/gorm/development.html#callbacks

func (*DB) Close 

func (s *DB) Close() error

Close close current db connection. If database connection is not an io.Closer, returns an error.

func (*DB) ColumnsScannerCallback 

func (s *DB) ColumnsScannerCallback(cb func(scope *Scope, record interface{}, columns []string, values []interface{})) *DB

func (*DB) Commit 

func (s *DB) Commit() *DB

Commit commit a transaction

func (*DB) CommonDB 

func (s *DB) CommonDB() SQLCommon

CommonDB return the underlying `*sql.DB` or `*sql.Tx` instance, mainly intended to allow coexistence with legacy non-AORM code.

func (*DB) Count 

func (s *DB) Count(value interface{}) *DB

Count get how many records for a model

func (*DB) Create 

func (s *DB) Create(value interface{}) *DB

Create insert the value into database

func (*DB) CreateTable 

func (s *DB) CreateTable(models ...interface{}) *DB

CreateTable create table for models

func (*DB) DB 

func (s *DB) DB() *sql.DB

DB get `*sql.DB` from current connection If the underlying database connection is not a *sql.DB, returns nil

func (*DB) Deadline 

func (s *DB) Deadline() (deadline time.Time, ok bool)

func (*DB) Debug 

func (s *DB) Debug() *DB

Debug start debug mode

func (*DB) DefaultColumnValue 

func (s *DB) DefaultColumnValue(valuer func(scope *Scope, record interface{}, column string) interface{}) *DB

func (*DB) Delete 

func (s *DB) Delete(value interface{}, where ...interface{}) *DB

Delete delete value match given conditions, if the value has primary key, then will including the primary key as condition

func (*DB) Dialect 

func (s *DB) Dialect() Dialector

Dialector get dialect

func (*DB) DisableAfterScanCallback 

func (s *DB) DisableAfterScanCallback(typs ...interface{}) *DB

Disable after scan callback. If typs not is empty, disable for typs, other else, disable for all

func (*DB) Done 

func (s *DB) Done() <-chan struct{}

func (*DB) DropColumn 

func (s *DB) DropColumn(column string) *DB

DropColumn drop a column

func (*DB) DropTable 

func (s *DB) DropTable(values ...interface{}) *DB

DropTable drop table for models

func (*DB) DropTableIfExists 

func (s *DB) DropTableIfExists(values ...interface{}) *DB

DropTableIfExists drop table if it is exist

func (*DB) DryRun 

func (s *DB) DryRun() *DB

DryRun perform a trial run with no changes

func (*DB) EnableAfterScanCallback 

func (s *DB) EnableAfterScanCallback(typs ...interface{}) *DB

Enable after scan callback. If typs not is empty, enable for typs, other else, enable for all. The disabled types will not be enabled unless they are specifically informed.

func (*DB) Err 

func (s *DB) Err() error

func (*DB) Exec 

func (s *DB) Exec(sql string, values ...interface{}) *DB

Exec execute raw sql

func (*DB) Exists 

func (s *DB) Exists(where ...interface{}) (ok bool, err error)

Exists used to query single column from a first model result as a map 

var createAt time.Time
db.Model(&User{}).Exists()

func (*DB) ExistsValue 

func (s *DB) ExistsValue(value interface{}, where ...interface{}) (ok bool, err error)

ExistsValue used to query single column from a first model result as a map 

var createAt time.Time
db.ExistsValue(&User{Name:"user name"})

func (*DB) ExtraSelect 

func (s *DB) ExtraSelect(key string, values []interface{}, query interface{}, args ...interface{}) *DB

ExtraSelect specify extra fields that you want to retrieve from database when querying

func (*DB) ExtraSelectCallback 

func (s *DB) ExtraSelectCallback(f ...func(recorde interface{}, data map[string]*ExtraResult)) *DB

ExtraSelectCalback specify extra select callbacks that you want to retrieve from database when querying

func (*DB) ExtraSelectFields 

func (s *DB) ExtraSelectFields(key string, value interface{}, names []string, callback func(scope *Scope, record interface{}), query interface{}, args ...interface{}) *DB

ExtraSelectFields specify extra fields that you want to retrieve from database when querying

func (*DB) ExtraSelectFieldsSetter 

func (s *DB) ExtraSelectFieldsSetter(key string, setter ExtraSelectFieldsSetter, structFields []*StructField, query interface{}, args ...interface{}) *DB

ExtraSelectFieldsSetter specify extra fields that you want to retrieve from database when querying

func (*DB) Find 

func (s *DB) Find(out interface{}, where ...interface{}) *DB

Find find records that match given conditions

func (*DB) First 

func (s *DB) First(out interface{}, where ...interface{}) *DB

First find first record that match given conditions, order by primary key

func (*DB) FirstOrCreate 

func (s *DB) FirstOrCreate(out interface{}, where ...interface{}) *DB

FirstOrCreate find first matched record or create a new one with given conditions (only works with struct, map conditions) https://jinzhu.github.io/gorm/crud.html#firstorcreate

func (*DB) FirstOrInit 

func (s *DB) FirstOrInit(out interface{}, where ...interface{}) *DB

FirstOrInit find first matched record or initialize a new one with given conditions (only works with struct, map conditions) https://jinzhu.github.io/gorm/crud.html#firstorinit

func (*DB) Get 

func (s *DB) Get(name string) (value interface{}, ok bool)

Get get setting by name

func (*DB) GetArgVariabler 

func (s *DB) GetArgVariabler(arg interface{}) (argVar ArgBinder)

func (*DB) GetAssigner 

func (s *DB) GetAssigner(typ reflect.Type) (assigner Assigner)

func (*DB) GetCurrentUser 

func (s *DB) GetCurrentUser() (user interface{}, ok bool)

func (*DB) GetCurrentUserID 

func (s *DB) GetCurrentUserID() (id interface{})

func (*DB) GetErrors 

func (s *DB) GetErrors() []error

GetErrors get happened errors from the db

func (*DB) Group 

func (s *DB) Group(query string) *DB

Group specify the group method on the find

func (*DB) HasBlockGlobalUpdate 

func (s *DB) HasBlockGlobalUpdate() bool

HasBlockGlobalUpdate return state of block

func (*DB) HasOrder 

func (s *DB) HasOrder() bool

HasOrder returns if order has be specified

func (*DB) HasTable 

func (s *DB) HasTable(value interface{}) bool

HasTable check has table or not

func (*DB) Having 

func (s *DB) Having(query interface{}, values ...interface{}) *DB

Having specify HAVING conditions for GROUP BY

func (*DB) InlinePreload 

func (s *DB) InlinePreload(column string, options ...*InlinePreloadOptions) *DB

Preload preload associations with given conditions 

db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)

func (*DB) InlinePreloadFields 

func (s *DB) InlinePreloadFields(value interface{}, fields ...string) *DB

InlinePreloadFields set inline preload fields of value type

func (*DB) Inside 

func (s *DB) Inside(name ...interface{}) *DB

func (*DB) InstantSet 

func (s *DB) InstantSet(name string, value interface{}) *DB

InstantSet instant set setting, will affect current db

func (*DB) IsEnabledAfterScanCallback 

func (s *DB) IsEnabledAfterScanCallback(typs ...interface{}) (ok bool)

Return if after scan callbacks has be enable. If typs is empty, return default, other else, return for informed typs.

func (*DB) Join 

func (s *DB) Join(fieldName, mode string, handler func()) *DB

Join specify Join field conditions 

db.Model(&User{}).Join("INNER", "Email")
// INNER JOIN emails ON emails.user_id = user.id

func (*DB) Joins 

func (s *DB) Joins(query string, args ...interface{}) *DB

Joins specify Joins conditions 

db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?", "jinzhu@example.org").Find(&user)

func (*DB) Last 

func (s *DB) Last(out interface{}, where ...interface{}) *DB

Last find last record that match given conditions, order by primary key

func (*DB) Limit 

func (s *DB) Limit(limit interface{}) *DB

Limit specify the number of records to be retrieved

func (*DB) LogMode 

func (s *DB) LogMode(enable bool) *DB

LogMode set log mode, `true` for detailed logs, `false` for no log, default, will only print error logs

func (*DB) Loggers 

func (s *DB) Loggers(tableName string, set ...bool) (clone *DB, sl *ScopeLoggers, ok bool)

func (*DB) Model 

func (s *DB) Model(value interface{}) *DB

Model specify the model you would like to run db operations 

// update all users's name to `hello`
db.Model(&User{}).Update("name", "hello")
// if user's primary key is non-blank, will use it as condition, then will only update the user's name to `hello`
db.Model(&user).Update("name", "hello")

func (*DB) ModelStructStorage 

func (s *DB) ModelStructStorage() *ModelStructStorage

ModelStructStorage get the model struct storage fom DB

func (*DB) ModifyColumn 

func (s *DB) ModifyColumn(column string, typ string) *DB

ModifyColumn modify column to type

func (*DB) New 

func (s *DB) New() *DB

New clone a new db connection without search conditions

func (*DB) NewScope 

func (s *DB) NewScope(value interface{}) *Scope

NewScope create a scope for current operation

func (*DB) Not 

func (s *DB) Not(query interface{}, args ...interface{}) *DB

Not filter records that don'T match current conditions, similar to `Where`

func (*DB) Offset 

func (s *DB) Offset(offset interface{}) *DB

Offset specify the number of records to skip before starting to return the records

func (*DB) Omit 

func (s *DB) Omit(columns ...string) *DB

Omit specify fields that you want to ignore when saving to database for creating, updating

func (*DB) Or 

func (s *DB) Or(query interface{}, args ...interface{}) *DB

Or filter records that match before conditions or this one, similar to `Where`

func (*DB) Order 

func (s *DB) Order(value interface{}, reorder ...bool) *DB

Order specify order when retrieve records from database, set reorder to `true` to overwrite defined conditions 

db.Order("name DESC")
db.Order("name DESC", true) // reorder
db.Order(aorm.Expr("name = ? DESC", "first")) // sql expression

func (*DB) Path 

func (s *DB) Path() []interface{}

func (*DB) PathString 

func (s *DB) PathString() string

func (*DB) Pluck 

func (s *DB) Pluck(column string, value interface{}) *DB

Pluck used to query single column from a model as a map 

var ages []int64
db.Find(&users).Pluck("age", &ages)

func (*DB) PluckFirst 

func (s *DB) PluckFirst(column string, value interface{}) *DB

PluckFirst used to query single column from a first model result as a map 

var createAt time.Time
db.Model(&User{}).Pluck("created_at", &createdAt)

func (*DB) Preload 

func (s *DB) Preload(column string, options ...*InlinePreloadOptions) *DB

Preload preload associations with given conditions 

db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)

func (*DB) QueryExpr 

func (s *DB) QueryExpr() *Query

QueryExpr returns the query as Query object

func (*DB) Raw 

func (s *DB) Raw(sql string, values ...interface{}) *DB

Raw use raw sql as conditions, won'T run it unless invoked by other methods 

db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)

func (*DB) RawTransaction 

func (s *DB) RawTransaction(f func(tx *sql.Tx) (err error)) (err error)

RawTransaction execute func `f` into sql.Tx

func (*DB) RecordNotFound 

func (s *DB) RecordNotFound() bool

RecordNotFound check if returning ErrRecordNotFound error

func (*DB) RegisterAssigner 

func (s *DB) RegisterAssigner(assigners ...Assigner) *DB

func (*DB) Related 

func (s *DB) Related(value interface{}, foreignKeys ...string) *DB

Related get related associations

func (*DB) RemoveForeignKey 

func (s *DB) RemoveForeignKey(field string, dest string) *DB

RemoveForeignKey Remove foreign key from the given scope, e.g: 

db.Model(&User{}).RemoveForeignKey("city_id", "cities(id)")

func (*DB) RemoveIndex 

func (s *DB) RemoveIndex(indexName string) *DB

RemoveIndex remove index with name

func (*DB) Rollback 

func (s *DB) Rollback() *DB

Rollback rollback a transaction

func (*DB) Row 

func (s *DB) Row() *sql.Row

Row return `*sql.Row` with given conditions

func (*DB) Rows 

func (s *DB) Rows() (*sql.Rows, error)

Rows return `*sql.Rows` with given conditions

func (*DB) Save 

func (s *DB) Save(value interface{}) *DB

Save update value in database, if the value doesn'T have primary key, will insert it

func (*DB) Scan 

func (s *DB) Scan(dest interface{}) *DB

Scan scan value to a struct

func (*DB) ScanRows 

func (s *DB) ScanRows(rows *sql.Rows, result interface{}) error

ScanRows scan `*sql.Rows` to give struct

func (*DB) ScopeErrorCallback 

func (s *DB) ScopeErrorCallback(cb func(scope *Scope, err error)) *DB

ScopeErrorCallback register error callback for scope

func (*DB) Scopes 

func (s *DB) Scopes(funcs ...func(*DB) *DB) *DB

Scopes pass current database connection to arguments `func(*DB) *DB`, which could be used to add conditions dynamically 

func AmountGreaterThan1000(db *aorm.DB) *aorm.DB {
    return db.Where("amount > ?", 1000)
}

func OrderStatus(status []string) func (db *aorm.DB) *aorm.DB {
    return func (db *aorm.DB) *aorm.DB {
        return db.Scopes(AmountGreaterThan1000).Where("status in (?)", status)
    }
}

db.Scopes(AmountGreaterThan1000, OrderStatus([]string{"paid", "shipped"})).Find(&orders)

Refer https://jinzhu.github.io/gorm/crud.html#scopes

func (*DB) Select 

func (s *DB) Select(query interface{}, args ...interface{}) *DB

Select specify fields that you want to retrieve from database when querying, by default, will select all fields; When creating/updating, specify fields that you want to save to database

func (*DB) Set 

func (s *DB) Set(name string, value interface{}) *DB

Set set setting by name, which could be used in callbacks, will clone a new db, and update its setting

func (*DB) SetCommonDB 

func (s *DB) SetCommonDB(db SQLCommon) *DB

SetCommonDB set the underlying `*sql.DB` or `*sql.Tx` instance, mainly intended to allow coexistence with legacy non-AORM code.

func (*DB) SetCurrentUser 

func (s *DB) SetCurrentUser(user interface{}) *DB

func (*DB) SetJoinTableHandler 

func (s *DB) SetJoinTableHandler(source interface{}, column string, handler JoinTableHandlerInterface)

SetJoinTableHandler set a model's join table handler for a relation

func (*DB) SetLogger 

func (s *DB) SetLogger(log logging.Logger)

SetLogger replace default logger

func (*DB) SetSingleUpdate 

func (s *DB) SetSingleUpdate(v bool) *DB

func (*DB) SetTableNameResolver 

func (db *DB) SetTableNameResolver(resolver TableNameResolver) *DB

func (*DB) SingleUpdate 

func (s *DB) SingleUpdate() bool

func (*DB) SingularTable 

func (s *DB) SingularTable(enable bool)

SingularTable use singular table by default

func (*DB) StoreBlankField 

func (s *DB) StoreBlankField() *DB

StoreBlankField set aorm:store_blank_field as true

func (*DB) StructOf 

func (s *DB) StructOf(value ...interface{}) *ModelStruct

StructOf get value's model struct, relationships based on struct and tag definition fom DB

func (*DB) SubQuery 

func (s *DB) SubQuery() *Query

SubQuery returns the query as sub query

func (*DB) Table 

func (s *DB) Table(name string) *DB

Table specify the table you would like to run db operations

func (*DB) Take 

func (s *DB) Take(out interface{}, where ...interface{}) *DB

Take return a record that match given conditions, the order will depend on the database implementation

func (*DB) Transaction 

func (s *DB) Transaction(f func(db *DB) (err error)) (err error)

Transaction execute func `f` into transaction

func (*DB) Unscoped 

func (s *DB) Unscoped() *DB

Unscoped return all record including deleted record, refer Soft Delete https://jinzhu.github.io/gorm/crud.html#soft-delete

func (*DB) Update 

func (s *DB) Update(attrs ...interface{}) *DB

Update update attributes with callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update

func (*DB) UpdateColumn 

func (s *DB) UpdateColumn(attrs ...interface{}) *DB

UpdateColumn update attributes without callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update

func (*DB) UpdateColumns 

func (s *DB) UpdateColumns(values interface{}) *DB

UpdateColumns update attributes without callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update

func (*DB) Updates 

func (s *DB) Updates(values interface{}, ignoreProtectedAttrs ...bool) *DB

Updates update attributes with callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update

func (*DB) Value 

func (s *DB) Value(key interface{}) interface{}

func (*DB) Where 

func (s *DB) Where(query interface{}, args ...interface{}) *DB

Where return a new relation, filter records with given conditions, accepts `map`, `struct` or `string` as conditions, refer http://jinzhu.github.io/gorm/crud.html#query

type DBNamer 

type DBNamer interface {
	DBName() string
}

type DbDataTyper 

type DbDataTyper interface {
	AormDataType(dialect Dialector) string
}

type DefaultKeyNamer 

type DefaultKeyNamer struct{}

DefaultKeyNamer contains the default foreign key name generator method

func (DefaultKeyNamer) BuildKeyName 

func (DefaultKeyNamer) BuildKeyName(kind, tableName string, fields ...string) string

BuildKeyName returns a valid key name (foreign key, index key) for the given table, field and reference

type DefinedID 

type DefinedID struct {
	ID bid.BID `aorm:"primary_key"`
}

type Dialector 

type Dialector interface {
	Quoter
	KeyNamer

	// Init the dialect
	Init()

	// Cast sql cast's from to
	Cast(from, to string) string

	// GetName get dialect's name
	GetName() string

	// SetDB set db for dialect
	SetDB(db SQLCommon)

	// BindVar return the placeholder for actual values in SQL statements, in many dbs it is "?", Postgres using $1
	BindVar(i int) string

	// DataTypeOf return data's sql type
	DataTypeOf(field *FieldStructure) string

	// HasIndex check has index or not
	HasIndex(tableName string, indexName string) bool
	// HasForeignKey check has foreign key or not
	HasForeignKey(tableName string, foreignKeyName string) bool
	// RemoveIndex remove index
	RemoveIndex(tableName string, indexName string) error
	// HasTable check has table or not
	HasTable(tableName string) bool
	// HasColumn check has column or not
	HasColumn(tableName string, columnName string) bool
	// ModifyColumn modify column's type
	ModifyColumn(tableName string, columnName string, typ string) error

	// LimitAndOffsetSQL return generated SQL with Limit and Offset, as mssql has special case
	LimitAndOffsetSQL(limit, offset interface{}) string
	// SelectFromDummyTable return select values, for most dbs, `SELECT values` just works, mysql needs `SELECT value FROM DUAL`
	SelectFromDummyTable() string
	// LastInsertIdReturningSuffix most dbs support LastInsertId, but postgres needs to use `RETURNING`
	LastInsertIDReturningSuffix(tableName, columnName string) string
	// DefaultValueStr
	DefaultValueStr() string

	// CurrentDatabase return current database name
	CurrentDatabase() string

	Assigners() map[reflect.Type]Assigner
	RegisterAssigner(assigner ...Assigner)
	GetAssigner(typ reflect.Type) (assigner Assigner)
	DuplicateUniqueIndexError(indexes IndexMap, tableName string, sqlErr error) (err error)
}

Dialector interface contains behaviors that differ across SQL database

func GetDialect 

func GetDialect(name string) (dialect Dialector, ok bool)

GetDialect gets the dialect for the specified dialect name

func MustGetDialect 

func MustGetDialect(name string) (dialect Dialector)

MustGetDialect gets the dialect for the specified dialect name

type DuplicateUniqueIndexError 

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

func GetDuplicateUniqueIndexError 

func GetDuplicateUniqueIndexError(err ...error) *DuplicateUniqueIndexError

func (DuplicateUniqueIndexError) Cause 

func (d DuplicateUniqueIndexError) Cause() error

func (DuplicateUniqueIndexError) Error 

func (d DuplicateUniqueIndexError) Error() string

func (DuplicateUniqueIndexError) Index 

func (d DuplicateUniqueIndexError) Index() *StructIndex

type Errors 

type Errors []error

Errors contains all happened errors

func (Errors) Add 

func (errs Errors) Add(newErrors ...error) Errors

Add adds an error

func (Errors) Error 

func (errs Errors) Error() string

error format happened errors

func (Errors) GetErrors 

func (errs Errors) GetErrors() []error

GetErrors gets all happened errors

type ExecState 

type ExecState struct {
	Query
	Value interface{}
}

type ExtraResult 

type ExtraResult struct {
	Select *extraSelect
	Values []interface{}
	Names  []string
	Map    map[string]int
}

func (*ExtraResult) Get 

func (er *ExtraResult) Get(name string) (v interface{}, ok bool)

type ExtraSelectFieldsSetter 

type ExtraSelectFieldsSetter func(result interface{}, values []interface{}, set func(result interface{}, low, hight int) interface{})

type ExtraSelectInterface 

type ExtraSelectInterface interface {
	SetAormExtraScannedValues(extra map[string]*ExtraResult)
	GetAormExtraScannedValue(name string) (result *ExtraResult, ok bool)
	GetAormExtraScannedValues() map[string]*ExtraResult
}

type ExtraSelectModel 

type ExtraSelectModel struct {
	ExtraScannedValues map[string]*ExtraResult `sql:"-"`
}

func (*ExtraSelectModel) GetAormExtraScannedValue 

func (es *ExtraSelectModel) GetAormExtraScannedValue(name string) (result *ExtraResult, ok bool)

func (*ExtraSelectModel) GetAormExtraScannedValues 

func (es *ExtraSelectModel) GetAormExtraScannedValues() map[string]*ExtraResult

func (*ExtraSelectModel) SetAormExtraScannedValues 

func (es *ExtraSelectModel) SetAormExtraScannedValues(extra map[string]*ExtraResult)

type Field 

type Field struct {
	*StructField
	IsBlank bool
	Field   reflect.Value
	// contains filtered or unexported fields
}

Field model field definition

func PrimaryFieldsOf 

func PrimaryFieldsOf(value interface{}) []*Field

PrimaryFieldsOf get the primary fields instance of value

func (*Field) CallMethodCallback 

func (this *Field) CallMethodCallback(name string, object reflect.Value, in ...reflect.Value)

Call the method callback

func (*Field) CallMethodCallbackArgs 

func (this *Field) CallMethodCallbackArgs(name string, object reflect.Value, in []reflect.Value)

func (*Field) ID 

func (this *Field) ID() (IDValuer, error)

func (*Field) Scaner 

func (this *Field) Scaner(dialect Dialector) Scanner

func (*Field) Set 

func (this *Field) Set(value interface{}) (err error)

Set set a value to the field

type FieldAssigner 

type FieldAssigner interface {
	AormAssigner() Assigner
}

type FieldSelectWraper 

type FieldSelectWraper interface {
	SelectWrap(field *StructField, scope *Scope, expr string) Query
}

type FieldSelector 

type FieldSelector interface {
	Select(field *StructField, scope *Scope, table string) Query
}

func NewFieldSelector 

func NewFieldSelector(selectorFunc FieldSelectorFunc) FieldSelector

type FieldSelectorFunc 

type FieldSelectorFunc = func(field *StructField, scope *Scope, expr string) Query

type FieldStructure 

type FieldStructure struct {
	Type         reflect.Type
	TagSettings  map[string]string
	Assigner     Assigner
	IsPrimaryKey bool
}

type FieldTypeTagSettinger 

type FieldTypeTagSettinger interface {
	TagSetting(field reflect.StructField) TagSetting
}

type FieldsForCreateAcceptor 

type FieldsForCreateAcceptor interface {
	AormAcceptFieldsForCreate(scope *Scope) (fields []string, apply bool)
}

type FieldsForCreateExcluder 

type FieldsForCreateExcluder interface {
	AormExcludeFieldsForCreate(scope *Scope) (fields []string, apply bool)
}

type FieldsForUpdateAcceptor 

type FieldsForUpdateAcceptor interface {
	AormAcceptFieldsForUpdate(scope *Scope) (fields []string, apply bool)
}

type FieldsForUpdateExcluder 

type FieldsForUpdateExcluder interface {
	AormExcludeFieldsForUpdate(scope *Scope) (fields []string, apply bool)
}

type Generator 

type Generator interface {
	Zeroer
	Generate()
}

type ID 

type ID interface {
	Zeroer
	WhereClauser
	fmt.Stringer
	Bytes() []byte
	Fields() []*StructField
	Field() *StructField
	Values() []IDValuer
	Value() IDValuer
	Raw() interface{}
	SetValue(value ...interface{}) (ID, error)
	SetTo(recorde interface{}) interface{}
	Exclude() ID
}

func FakeID 

func FakeID(v string) ID

func IDSlice 

func IDSlice(args ...interface{}) (r []ID)

func IdOf 

func IdOf(value interface{}) ID

IdOf get ID of model value

type IDSlicer 

type IDSlicer interface {
	Values() []ID
	Exclude() IDSlicer
}

type IDValueRawConverter 

type IDValueRawConverter interface {
	FromRaw(raw interface{}) IDValuer
	ToRaw(value IDValuer) interface{}
}

func IDValueRawConverterGet 

func IDValueRawConverterGet(typ reflect.Type) (converter IDValueRawConverter)

type IDValuer 

type IDValuer interface {
	Bytes() []byte
	fmt.Stringer
	Zeroer
	Raw() interface{}
	ParseString(s string) (value IDValuer, err error)
	ParseBytes(s []byte) (value IDValuer, err error)
}

type Id 

type Id struct {
	TableName string
	// contains filtered or unexported fields
}

func NewId 

func NewId(fields []*StructField, values []IDValuer) *Id

func (Id) Bytes 

func (this Id) Bytes() (b []byte)

func (Id) Exclude 

func (this Id) Exclude() ID

func (Id) Field 

func (this Id) Field() *StructField

func (Id) Fields 

func (this Id) Fields() []*StructField

func (Id) IsZero 

func (this Id) IsZero() bool

func (Id) Raw 

func (this Id) Raw() interface{}

func (Id) SetTo 

func (this Id) SetTo(recorde interface{}) interface{}

func (Id) SetValue 

func (this Id) SetValue(value ...interface{}) (_ ID, err error)

func (Id) String 

func (this Id) String() string

func (Id) Value 

func (this Id) Value() IDValuer

func (Id) Values 

func (this Id) Values() []IDValuer

func (Id) WhereClause 

func (this Id) WhereClause(scope *Scope) (result Query)

type IndexMap 

type IndexMap map[string]*StructIndex

func (IndexMap) FromColumns 

func (this IndexMap) FromColumns(columns ...string) (ix *StructIndex)

FromColumns return index from db column names

func (IndexMap) FromDbName 

func (this IndexMap) FromDbName(namer KeyNamer, tableName, indexDbName string) (ix *StructIndex)

FromDbName return index from db name

type InlinePreloadBuilder 

type InlinePreloadBuilder struct {
	*Conditions
	*InlinePreloadInfo
}

type InlinePreloadFields 

type InlinePreloadFields interface {
	GetAormInlinePreloadFields() []string
}

type InlinePreloadFieldsWithScope 

type InlinePreloadFieldsWithScope interface {
	GetAormInlinePreloadFields(scope *Scope) []string
}

type InlinePreloadInfo 

type InlinePreloadInfo struct {
	RootScope, ParentScope, Scope *Scope
	Preloader                     *InlinePreloader
	Conditions                    *Conditions
}

type InlinePreloadOptions 

type InlinePreloadOptions struct {
	Conditions
	RelatedConditions []interface{}
	Select            []interface{}
	Join              JoinType
	Prepare           func(builder *InlinePreloadBuilder)
}

type InlinePreloader 

type InlinePreloader struct {
	RootScope,
	Scope,
	ParentScope *Scope
	DB             *DB
	ID             string
	Field          *StructField
	VirtualField   *VirtualField
	Index          [][]int
	RelationFields []*StructField
	StructFields   []*StructField
	Query          string
}

func (*InlinePreloader) Apply 

func (p *InlinePreloader) Apply()

func (*InlinePreloader) Fields 

func (p *InlinePreloader) Fields(fields ...interface{})

func (*InlinePreloader) GetFields 

func (p *InlinePreloader) GetFields() []*StructField

func (*InlinePreloader) GetQuery 

func (p *InlinePreloader) GetQuery() string

func (*InlinePreloader) Scan 

func (p *InlinePreloader) Scan(result interface{}, values []interface{}, set func(result interface{}, low, hight int) interface{})

type InlinePreloads 

type InlinePreloads struct {
	Count uint
	// map of field path -> alias_name
	DBNames map[string]string
}

func (*InlinePreloads) GetDBName 

func (c *InlinePreloads) GetDBName(path string) (dbName string, ok bool)

func (*InlinePreloads) Next 

func (c *InlinePreloads) Next(fieldPath ...string) string

type InlineQueries 

type InlineQueries []*WithInlineQuery

func (InlineQueries) Join 

func (iq InlineQueries) Join(sep ...string) (result *WithInlineQuery)

type Instance 

type Instance struct {
	Struct       *ModelStruct
	ReflectValue reflect.Value
	Value        interface{}
	FieldsMap    map[string]*Field
	Fields       []*Field
	Primary      []*Field
}

func InstanceOf 

func InstanceOf(value interface{}, fieldsNames ...string) *Instance

InstanceOf get instance of model value

func (*Instance) FieldByName 

func (this *Instance) FieldByName(name string) (field *Field, ok bool)

FieldByName find `aorm.Field` with field name or db name

func (*Instance) ID 

func (this *Instance) ID() ID

func (*Instance) MustFieldByName 

func (this *Instance) MustFieldByName(name string) (field *Field)

MustFieldByName find `aorm.Field` with field name or db name

func (*Instance) PrimaryField 

func (this *Instance) PrimaryField() *Field

PrimaryField return main primary field, if defined more that one primary fields, will return the one having column name `id` or the first one

func (*Instance) RelatedFields 

func (this *Instance) RelatedFields() []*Field

type IntId 

type IntId int64

func (IntId) Bytes 

func (this IntId) Bytes() []byte

func (IntId) Int 

func (this IntId) Int() int64

func (IntId) IsZero 

func (this IntId) IsZero() bool

func (IntId) ParseBytes 

func (this IntId) ParseBytes(b []byte) (IDValuer, error)

func (IntId) ParseString 

func (this IntId) ParseString(s string) (_ IDValuer, err error)

func (IntId) Raw 

func (this IntId) Raw() interface{}

func (IntId) String 

func (this IntId) String() string

type IteratorHeader 

type IteratorHeader struct {
	Value interface{}
}

type JoinTableForeignKey 

type JoinTableForeignKey struct {
	DBName           string
	AssociationField *StructField
}

JoinTableForeignKey join table foreign key struct

type JoinTableHandler 

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

JoinTableHandler default join table handler

func NewJoinTableHandler 

func NewJoinTableHandler(tableName string, source JoinTableSource, destination JoinTableSource) *JoinTableHandler

func (JoinTableHandler) Add 

func (this JoinTableHandler) Add(handler JoinTableHandlerInterface, db *DB, source interface{}, destination interface{}) (err error)

Add create relationship in join table for source and destination

func (JoinTableHandler) Delete 

func (this JoinTableHandler) Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error

Delete delete relationship in join table for sources

func (*JoinTableHandler) Destination 

func (this *JoinTableHandler) Destination() JoinTableSource

func (*JoinTableHandler) DestinationForeignKeys 

func (this *JoinTableHandler) DestinationForeignKeys() []JoinTableForeignKey

DestinationForeignKeys return destination foreign keys

func (JoinTableHandler) JoinWith 

func (this JoinTableHandler) JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB

JoinWith query with `Join` conditions

func (*JoinTableHandler) Setup 

func (this *JoinTableHandler) Setup(relationship *Relationship, tableName string, source, destination *ModelStruct)

Setup initialize a default join table handler

func (*JoinTableHandler) Source 

func (this *JoinTableHandler) Source() JoinTableSource

func (*JoinTableHandler) SourceForeignKeys 

func (this *JoinTableHandler) SourceForeignKeys() []JoinTableForeignKey

SourceForeignKeys return source foreign keys

func (JoinTableHandler) Table 

func (this JoinTableHandler) Table(db *DB) string

Table return join table's table name

func (*JoinTableHandler) TableName 

func (this *JoinTableHandler) TableName() string

type JoinTableHandlerInterface 

type JoinTableHandlerInterface interface {
	TableNamer

	// initialize join table handler
	Setup(relationship *Relationship, tableName string, source, destination *ModelStruct)
	// Table return join table's table name
	Table(db *DB) string
	// Add create relationship in join table for source and destination
	Add(handler JoinTableHandlerInterface, db *DB, source interface{}, destination interface{}) error
	// Delete delete relationship in join table for sources
	Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error
	// JoinWith query with `Join` conditions
	JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB
	// SourceForeignKeys return source foreign keys
	SourceForeignKeys() []JoinTableForeignKey
	// DestinationForeignKeys return destination foreign keys
	DestinationForeignKeys() []JoinTableForeignKey

	Source() JoinTableSource
	Destination() JoinTableSource
}

JoinTableHandlerInterface is an interface for how to handle many2many relations

type JoinTableSource 

type JoinTableSource struct {
	ModelStruct *ModelStruct
	ForeignKeys []JoinTableForeignKey
}

JoinTableSource is a struct that contains model type and foreign keys

type JoinType 

type JoinType uint
const (
	JoinLeft JoinType = iota
	JoinInner
	JoinRight
)

func (JoinType) IsInner 

func (ipo JoinType) IsInner() bool

func (JoinType) IsLeft 

func (ipo JoinType) IsLeft() bool

func (JoinType) IsRight 

func (ipo JoinType) IsRight() bool

func (JoinType) String 

func (ipo JoinType) String() string

type KVStorager 

type KVStorager interface {
	Set(key string, value string)
	Get(key string) string
}

type KeyNamer 

type KeyNamer interface {
	// BuildKeyName returns a valid key name (foreign key, index key) for the given table, field and reference
	BuildKeyName(kind, tableName string, fields ...string) string
}

func KeyNameBuilderOf 

func KeyNameBuilderOf(f KeyNamerFunc) KeyNamer

type KeyNamerFunc 

type KeyNamerFunc = func(kind, tableName string, fields ...string) string

type Method 

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

func MethodByName 

func MethodByName(typ reflect.Type, name string) (m Method)

func (Method) Index 

func (m Method) Index() int

func (Method) Name 

func (m Method) Name() string

func (Method) ObjectMethod 

func (m Method) ObjectMethod(object reflect.Value) reflect.Value

func (Method) Ptr 

func (m Method) Ptr() bool

func (Method) TypeMethod 

func (m Method) TypeMethod(typ reflect.Type) reflect.Method

func (Method) Valid 

func (m Method) Valid() bool

type Model 

type Model struct {
	ID bid.BID `aorm:"primary_key;serial"`
}

Model base model definition, including fields `BID`, `CreatedAt`, `UpdatedAt`, `DeletedAt`, which could be embedded in your models 

type User struct {
  aorm.Model
}

type ModelStruct 

type ModelStruct struct {
	TableNameResolver      func(ctx context.Context, singular bool) (tableName string)
	Value                  interface{}
	PrimaryFields          []*StructField
	Fields                 []*StructField
	RelatedFields          []*StructField
	ReadOnlyFields         []*StructField
	DynamicFieldsByName    map[string]*StructField
	Type                   reflect.Type
	PluralTableName        string
	SingularTableName      string
	FieldsByName           map[string]*StructField
	IgnoredFieldsCount     int
	BeforeRelatedCallbacks []func(fromScope *Scope, toScope *Scope, db *DB, fromField *Field) *DB

	Indexes       IndexMap
	UniqueIndexes IndexMap
	// contains filtered or unexported fields
}

ModelStruct model definition

func StructOf 

func StructOf(value interface{}) *ModelStruct

StructOf get value's model struct, relationships based on struct and tag definition for value

func (*ModelStruct) AutoInlinePreload 

func (this *ModelStruct) AutoInlinePreload(virtualFieldName ...string)

AutoInlinePreload set default auto inline preload virtual field names

func (*ModelStruct) BeforeRelatedCallback 

func (this *ModelStruct) BeforeRelatedCallback(cb ...func(fromScope *Scope, toScope *Scope, db *DB, fromField *Field) *DB)

func (*ModelStruct) CreateFieldByName 

func (this *ModelStruct) CreateFieldByName(value interface{}, fieldName string) (field *Field, ok bool)

func (*ModelStruct) DefaultID 

func (this *ModelStruct) DefaultID() ID

func (*ModelStruct) FieldByName 

func (this *ModelStruct) FieldByName(name string) (field *StructField, ok bool)

FieldByName find `aorm.StructField` with field name or db name

func (*ModelStruct) FieldByPath 

func (this *ModelStruct) FieldByPath(pth string) (field *StructField)

FieldByPath return field byte path

func (*ModelStruct) FieldDiscovery 

func (this *ModelStruct) FieldDiscovery(pth string) (field *StructField, virtualField *VirtualField)

FieldDiscovery discovery field from name or path

func (*ModelStruct) FirstFieldValue 

func (this *ModelStruct) FirstFieldValue(value interface{}, names ...string) (field *Field)

func (*ModelStruct) Fqn 

func (this *ModelStruct) Fqn() string

func (*ModelStruct) GetID 

func (this *ModelStruct) GetID(record interface{}) ID

func (*ModelStruct) GetVirtualField 

func (this *ModelStruct) GetVirtualField(fieldName string) *VirtualField

func (*ModelStruct) HasID 

func (this *ModelStruct) HasID() bool

HasID returns if has main primary field

func (*ModelStruct) InstanceOf 

func (this *ModelStruct) InstanceOf(value interface{}, fieldsNames ...string) (fields *Instance)

func (*ModelStruct) IsSoftDelete 

func (this *ModelStruct) IsSoftDelete() bool

func (*ModelStruct) MustCreateFieldByName 

func (this *ModelStruct) MustCreateFieldByName(value interface{}, fieldName string) (field *Field)

func (*ModelStruct) NonIgnoredStructFields 

func (this *ModelStruct) NonIgnoredStructFields() []*StructField

GetNonIgnoredStructFields get non ignored model's field structs

func (*ModelStruct) NonRelatedStructFields 

func (this *ModelStruct) NonRelatedStructFields() []*StructField

NonRelatedStructFields get non ignored model's field structs

func (*ModelStruct) NormalStructFields 

func (this *ModelStruct) NormalStructFields() (fields []*StructField)

GetNonIgnoredStructFields get non ignored model's field structs

func (*ModelStruct) ParseIDBytes 

func (this *ModelStruct) ParseIDBytes(b []byte) (_ ID, err error)

func (*ModelStruct) ParseIDString 

func (this *ModelStruct) ParseIDString(s string) (_ ID, err error)

func (*ModelStruct) PrimaryField 

func (this *ModelStruct) PrimaryField() *StructField

PrimaryField return main primary field, if defined more that one primary fields, will return the one having column name `id` or the first one

func (*ModelStruct) PrimaryFieldsInstance 

func (this *ModelStruct) PrimaryFieldsInstance(value interface{}) (fields []*Field)

func (*ModelStruct) RealTableName 

func (this *ModelStruct) RealTableName(ctx context.Context, singular bool) (name string)

RealTableName get real table name

func (*ModelStruct) SetIdFromString 

func (this *ModelStruct) SetIdFromString(record interface{}, idstr string) (err error)

func (*ModelStruct) SetVirtualField 

func (this *ModelStruct) SetVirtualField(fieldName string, value interface{}) *VirtualField

func (*ModelStruct) TableName 

func (this *ModelStruct) TableName(ctx context.Context, singular bool) string

tableName get model's table name

func (*ModelStruct) UniqueIdexesNamesMap 

func (this *ModelStruct) UniqueIdexesNamesMap(namer KeyNamer, tableName string) map[string]*StructIndex

UniqueIdexesNamesMap return unique idexes by index name map

type ModelStructStorage 

type ModelStructStorage struct {
	ModelStructsMap    *safeModelStructsMap
	TableNameResolvers []TableNameResolver
	GetAssigner        func(typ reflect.Type) Assigner
}

func NewModelStructStorage 

func NewModelStructStorage() *ModelStructStorage

func (*ModelStructStorage) GetOrNew 

func (this *ModelStructStorage) GetOrNew(value interface{}, callback ...func(modelStruct *ModelStruct)) (modelStruct *ModelStruct, err error)

type ModelTS 

type ModelTS struct {
	Model
	Timestamps
}

type ModelWithVirtualFields 

type ModelWithVirtualFields interface {
	VirtualFieldsGetter
	VirtualFieldsSetter
}

type OnRelated 

type OnRelated interface {
	AormOnRelated(fromScope, scope *Scope, db *DB) *DB
}

type OnRelatedField 

type OnRelatedField interface {
	AormOnRelatedField(fromScope, scope *Scope, db *DB, field *Field) *DB
}

type Operation 

type Operation string
const (
	OpQuery  Operation = "select"
	OpCreate Operation = "create"
	OpUpdate Operation = "update"
	OpDelete Operation = "delete"
)

type PathError 

type PathError interface {
	error
	Path() string
}

type Query 

type Query struct {
	Query string
	Args  Vars
}

func Expr 

func Expr(expression string, args ...interface{}) *Query

Expr generate raw SQL expression, for example: 

DB.Model(&product).Update("price", aorm.Expr("price * ? + ?", 2, 100))

func (*Query) AddArgs 

func (this *Query) AddArgs(arg ...interface{}) *Query

func (Query) Build 

func (this Query) Build(appender ToVarsAppender) (query string, err error)

func (Query) String 

func (this Query) String() string

func (Query) Wrap 

func (this Query) Wrap(prefix, sufix string) Query

type QueryError 

type QueryError struct {
	QueryInfo
	// contains filtered or unexported fields
}

Represents Query error

func GetQueryError 

func GetQueryError(err ...error) *QueryError

func NewQueryError 

func NewQueryError(cause error, q Query, varBinder func(i int) string) *QueryError

func (*QueryError) Cause 

func (e *QueryError) Cause() error

Returns the original error

func (*QueryError) Error 

func (e *QueryError) Error() string

type QueryInfo 

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

Represents Query with args Info

func NewQueryInfo 

func NewQueryInfo(q Query, varBinder func(i int) string) *QueryInfo

func (*QueryInfo) Args 

func (e *QueryInfo) Args() []interface{}

func (*QueryInfo) ArgsName 

func (e *QueryInfo) ArgsName() []string

func (*QueryInfo) EachArgs 

func (e *QueryInfo) EachArgs(cb func(i int, name string, value interface{}))

func (*QueryInfo) Sql 

func (e *QueryInfo) Sql() string

func (*QueryInfo) String 

func (e *QueryInfo) String() string

type QuoteRuner 

type QuoteRuner rune

func (QuoteRuner) QuoteChar 

func (this QuoteRuner) QuoteChar() rune

type Quoter 

type Quoter interface {
	// DefaultQuoter quotes char for field name to avoid SQL parsing exceptions by using a reserved word as a field name
	QuoteChar() rune
}

type RecordsIterator 

type RecordsIterator interface {
	Start() (state interface{}, err error)
	Done(state interface{}) (ok bool)
	Next(state interface{}) (recorde, newState interface{}, err error)
}

type RecordsIteratorOpener 

type RecordsIteratorOpener interface {
	Open() (header interface{}, it RecordsIterator, err error)
}

type Relationship 

type Relationship struct {
	Model, AssociationModel      *ModelStruct
	Kind                         string
	FieldName                    string
	PolymorphicType              string
	PolymorphicDBName            string
	PolymorphicValue             func(ctx context.Context, singular bool) string
	ForeignFieldNames            []string
	ForeignDBNames               []string
	AssociationForeignFieldNames []string
	AssociationForeignDBNames    []string
	JoinTableHandler             JoinTableHandlerInterface
}

Relationship described the relationship between models

func (*Relationship) AssoctiationFields 

func (this *Relationship) AssoctiationFields() []*StructField

func (*Relationship) DefaultRelatedID 

func (this *Relationship) DefaultRelatedID() (id ID)

func (*Relationship) ForeignFields 

func (this *Relationship) ForeignFields() []*StructField

func (*Relationship) GetRelatedID 

func (this *Relationship) GetRelatedID(record interface{}) (id ID)

func (*Relationship) InstanceToRelatedID 

func (this *Relationship) InstanceToRelatedID(instance *Instance) (id ID)

func (*Relationship) RelatedFields 

func (this *Relationship) RelatedFields() []*StructField

func (*Relationship) SetRelatedID 

func (this *Relationship) SetRelatedID(record interface{}, id ID)

type Reseter 

type Reseter interface {
	Reset()
}

type RowQueryResult 

type RowQueryResult struct {
	Row *sql.Row
}

type RowsQueryResult 

type RowsQueryResult struct {
	Rows  *sql.Rows
	Error error
}

type SQLCommon 

type SQLCommon interface {
	Exec(query string, args ...interface{}) (sql.Result, error)
	Prepare(query string) (*sql.Stmt, error)
	Query(query string, args ...interface{}) (*sql.Rows, error)
	QueryRow(query string, args ...interface{}) *sql.Row
}

SQLCommon is the minimal database connection functionality gorm requires. Implemented by *sql.DB.

type SQLSizer 

type SQLSizer interface {
	SQLSize(dialect Dialector) int
}

type SafeNameBuilder 

type SafeNameBuilder struct {
	Cache             KVStorager
	PreFormat, Format func(v string) string
}

func NewSafeNameBuilder 

func NewSafeNameBuilder(cache KVStorager, format ...func(v string) string) *SafeNameBuilder

func (*SafeNameBuilder) Build 

func (this *SafeNameBuilder) Build(name string) string

func (*SafeNameBuilder) BuildParts 

func (this *SafeNameBuilder) BuildParts(name string, sep string) string

type Scanner 

type Scanner = sql.Scanner

func ScannerFunc 

func ScannerFunc(f func(src interface{}) error) Scanner

type Scope 

type Scope struct {
	Query
	Search *search
	Value  interface{}

	ExecTime time.Time

	Operation Operation
	// contains filtered or unexported fields
}

Scope contain current operation's information when you perform any operation on the database

func (*Scope) AddToVars 

func (scope *Scope) AddToVars(value interface{}) (replacement string)

AddToVars add value as sql's vars, used to prevent SQL injection

func (*Scope) AutoInlinePreload 

func (s *Scope) AutoInlinePreload() *Scope

AutoInlinePreload preload associations

func (*Scope) Begin 

func (scope *Scope) Begin() *Scope

Begin start a transaction

func (*Scope) CallMethod 

func (scope *Scope) CallMethod(methodName string)

CallMethod call scope value's Method, if it is a slice, will call its element's Method one by one

func (*Scope) Clause 

func (scope *Scope) Clause(clause interface{}) string

func (*Scope) ClauseToSql 

func (scope *Scope) ClauseToSql(clause interface{}) (string, bool)

func (*Scope) CombinedConditionSql 

func (scope *Scope) CombinedConditionSql() string

CombinedConditionSql return combined condition sql

func (*Scope) CommitOrRollback 

func (scope *Scope) CommitOrRollback() *Scope

CommitOrRollback commit current transaction if no error happened, otherwise will rollback it

func (*Scope) Context 

func (scope *Scope) Context() context.Context

func (*Scope) DB 

func (scope *Scope) DB() *DB

DB return scope's DB connection

func (*Scope) Dialect 

func (scope *Scope) Dialect() Dialector

Dialector get dialect

func (*Scope) Err 

func (scope *Scope) Err(err error) error

Err add error to Scope

func (*Scope) Error 

func (scope *Scope) Error() error

error return error

func (*Scope) ErrorCallbacks 

func (s *Scope) ErrorCallbacks() (callbacks []func(scope *Scope, err error))

func (*Scope) Exec 

func (scope *Scope) Exec() *Scope

Exec perform generated SQL

func (*Scope) ExecResult 

func (scope *Scope) ExecResult() sql.Result

ExecResult perform generated SQL and return result

func (*Scope) FieldByName 

func (scope *Scope) FieldByName(name string) (field *Field, ok bool)

CreateFieldByName find `aorm.Field` with field name or db name

func (*Scope) Get 

func (scope *Scope) Get(name string) (interface{}, bool)

Get get setting by name

func (*Scope) GetBool 

func (scope *Scope) GetBool(name string, defaul ...bool) bool

GetBool get boolean setting by name ou default

func (*Scope) GetCurrentUserID 

func (scope *Scope) GetCurrentUserID() (id interface{})

func (*Scope) GetNonIgnoredStructFields 

func (scope *Scope) GetNonIgnoredStructFields() []*StructField

GetNonIgnoredStructFields get non ignored model's field structs

func (*Scope) GetNonRelatedStructFields 

func (scope *Scope) GetNonRelatedStructFields() []*StructField

GetNonIgnoredStructFields get non ignored model's field structs

func (*Scope) GetStructFields 

func (scope *Scope) GetStructFields() (fields []*StructField)

GetStructFields get model's field structs

func (*Scope) GetVirtualField 

func (s *Scope) GetVirtualField(fieldName string) *VirtualField

func (*Scope) HasColumn 

func (scope *Scope) HasColumn(column string) bool

HasColumn to check if has column

func (*Scope) HasError 

func (scope *Scope) HasError() bool

HasError check if there are any error

func (*Scope) HasPrimaryFields 

func (scope *Scope) HasPrimaryFields() (ok bool)

HasPrimaryFields return if scope's has primary fields

func (*Scope) ID 

func (scope *Scope) ID() ID

ID get value's id

func (*Scope) IndirectValue 

func (scope *Scope) IndirectValue() reflect.Value

IndirectValue return scope's reflect value's indirect value

func (*Scope) InlinePreloadFields 

func (s *Scope) InlinePreloadFields(value interface{}, fields ...string) *Scope

InlinePreloadFields set inline preload fields of value type

func (*Scope) InlinePreloads 

func (scope *Scope) InlinePreloads() *InlinePreloads

func (*Scope) Instance 

func (scope *Scope) Instance() *Instance

Instance get value's instance

func (*Scope) InstanceGet 

func (scope *Scope) InstanceGet(name string) (interface{}, bool)

InstanceGet get instance setting from current operation

func (*Scope) InstanceGetBool 

func (scope *Scope) InstanceGetBool(name string, defaul ...bool) bool

InstanceGetBool get boolean instance setting from current operation

func (*Scope) InstanceID 

func (scope *Scope) InstanceID() string

InstanceID get InstanceID for scope

func (*Scope) InstanceSet 

func (scope *Scope) InstanceSet(name string, value interface{}) *Scope

InstanceSet set instance setting for current operation, but not for operations in callbacks, like saving associations callback

func (*Scope) Log 

func (scope *Scope) Log(v ...interface{})

Log print log message

func (*Scope) Loggers 

func (s *Scope) Loggers(set ...bool) (sl *ScopeLoggers, ok bool)

func (*Scope) MustFieldByName 

func (scope *Scope) MustFieldByName(name string) (field *Field)

MustFieldByName find `aorm.Field` with field name or db name

func (*Scope) MustLoggers 

func (s *Scope) MustLoggers(set ...bool) (sl *ScopeLoggers)

func (*Scope) New 

func (scope *Scope) New(value interface{}) *Scope

New create a new Scope without search information

func (*Scope) NewDB 

func (scope *Scope) NewDB() *DB

NewDB create a new DB without search information

func (*Scope) OmitAttrs 

func (scope *Scope) OmitAttrs() []string

OmitAttrs return omitted attributes

func (*Scope) PrimaryField 

func (scope *Scope) PrimaryField() *Field

PrimaryField return scope's main primary field, if defined more that one primary fields, will return the one having column name `id` or the first one

func (*Scope) PrimaryFields 

func (scope *Scope) PrimaryFields() (fields []*Field)

PrimaryFields return scope's primary fields

func (*Scope) PrimaryKey 

func (scope *Scope) PrimaryKey() interface{}

PrimaryKey get the primary key's value

func (*Scope) PrimaryKeyDbName 

func (scope *Scope) PrimaryKeyDbName() string

PrimaryKeyDbName get main primary field's db name

func (*Scope) PrimaryKeyZero 

func (scope *Scope) PrimaryKeyZero() bool

PrimaryKeyZero check main primary field's value is blank or not

func (*Scope) Quote 

func (scope *Scope) Quote(str string) string

Quote used to quote string to escape them for database

func (*Scope) QuotedTableName 

func (scope *Scope) QuotedTableName() (name string)

QuotedTableName return quoted table name

func (*Scope) Raw 

func (scope *Scope) Raw(sql string) *Scope

Raw set raw sql

func (*Scope) RealTableName 

func (scope *Scope) RealTableName() (name string)

tableName return table name

func (*Scope) ResultSender 

func (scope *Scope) ResultSender() (dest reflect.Value, send func(el reflect.Value))

ResultSender return scope's value's result sender

func (*Scope) SQLDB 

func (scope *Scope) SQLDB() SQLCommon

SQLDB return *sql.DB

func (*Scope) ScopeOfField 

func (scope *Scope) ScopeOfField(fieldName string) *Scope

func (*Scope) SelectAttrs 

func (scope *Scope) SelectAttrs() []string

SelectAttrs return selected attributes

func (*Scope) Set 

func (scope *Scope) Set(name string, value interface{}) *Scope

Set set value by name

func (*Scope) SetColumn 

func (scope *Scope) SetColumn(column interface{}, value interface{}) error

SetColumn to set the column's value, column could be field or field's name/dbname

func (*Scope) SetVirtualField 

func (s *Scope) SetVirtualField(fieldName string, value interface{}, options ...map[interface{}]interface{}) (vf *VirtualField)

func (*Scope) SkipLeft 

func (scope *Scope) SkipLeft()

SkipLeft skip remaining callbacks

func (*Scope) Struct 

func (scope *Scope) Struct() *ModelStruct

Struct get value's model struct, relationships based on struct and tag definition

func (*Scope) StructOf 

func (scope *Scope) StructOf(value interface{}) *ModelStruct

StructOf get value's model struct, relationships based on struct and tag definition for value

func (*Scope) TableName 

func (scope *Scope) TableName() string

tableName return table name

func (*Scope) ValuesFields 

func (scope *Scope) ValuesFields(structFields []*StructField) []*Field

ValuesFields create value's fields from structFields

type ScopeLoggers 

type ScopeLoggers struct {
	Async bool
	// contains filtered or unexported fields
}

func (*ScopeLoggers) All 

func (s *ScopeLoggers) All(callback func(action string, scope *Scope)) *ScopeLoggers

func (*ScopeLoggers) Call 

func (s *ScopeLoggers) Call(action string, scope *Scope)

func (*ScopeLoggers) Create 

func (s *ScopeLoggers) Create(callback func(action string, scope *Scope)) *ScopeLoggers

func (*ScopeLoggers) Crud 

func (s *ScopeLoggers) Crud(callback func(action string, scope *Scope)) *ScopeLoggers

func (*ScopeLoggers) Delete 

func (s *ScopeLoggers) Delete(callback func(action string, scope *Scope)) *ScopeLoggers

func (*ScopeLoggers) Exec 

func (s *ScopeLoggers) Exec(callback func(action string, scope *Scope)) *ScopeLoggers

func (*ScopeLoggers) Many 

func (s *ScopeLoggers) Many(callback func(action string, scope *Scope), actions ...string) *ScopeLoggers

func (*ScopeLoggers) Query 

func (s *ScopeLoggers) Query(callback func(action string, scope *Scope)) *ScopeLoggers

func (*ScopeLoggers) Register 

func (s *ScopeLoggers) Register(action string, callback func(action string, scope *Scope)) *ScopeLoggers

func (*ScopeLoggers) Update 

func (s *ScopeLoggers) Update(callback func(action string, scope *Scope)) *ScopeLoggers

type Selector 

type Selector interface {
	Select(scope *Scope, tableName string) Query
}

type SimpleAssigner 

type SimpleAssigner struct {
	ValuerFunc  func(dialect Dialector, value interface{}) driver.Valuer
	ScanerFunc  func(dialect Dialector, dest reflect.Value) Scanner
	Typ         reflect.Type
	SQLtype     string
	SQLtypeFunc func(dialect Dialector) string
}

func (*SimpleAssigner) SQLType 

func (assigner *SimpleAssigner) SQLType(dialect Dialector) string

func (*SimpleAssigner) Scaner 

func (assigner *SimpleAssigner) Scaner(dialect Dialector, dest reflect.Value) Scanner

func (*SimpleAssigner) Type 

func (assigner *SimpleAssigner) Type() reflect.Type

func (*SimpleAssigner) Valuer 

func (assigner *SimpleAssigner) Valuer(dialect Dialector, value interface{}) driver.Valuer

type SoftDelete 

type SoftDelete struct {
	DeletedAt *time.Time `sql:"index"`
}

func (*SoftDelete) GetDeletedAt 

func (d *SoftDelete) GetDeletedAt() *time.Time

type SoftDeleteAudited 

type SoftDeleteAudited struct {
	SoftDelete
	DeletedByID bid.BID
}

func (*SoftDeleteAudited) GetDeletedBy 

func (a *SoftDeleteAudited) GetDeletedBy() interface{}

func (*SoftDeleteAudited) SetDeletedBy 

func (a *SoftDeleteAudited) SetDeletedBy(deletedBy interface{})

type SoftDeleteAuditor 

type SoftDeleteAuditor interface {
	SoftDeleter
	SetDeletedBy(deletedBy interface{})
	GetDeletedBy() *string
}

type SoftDeleter 

type SoftDeleter interface {
	GetDeletedAt() *time.Time
}

type SqlClauser 

type SqlClauser interface {
	SqlClause(scope *Scope) (query string)
}

type StrId 

type StrId string

func (StrId) Bytes 

func (this StrId) Bytes() []byte

func (StrId) IsZero 

func (this StrId) IsZero() bool

func (StrId) ParseBytes 

func (StrId) ParseBytes(b []byte) (IDValuer, error)

func (StrId) ParseString 

func (StrId) ParseString(s string) (IDValuer, error)

func (StrId) Raw 

func (this StrId) Raw() interface{}

func (StrId) String 

func (this StrId) String() string

type StringParser 

type StringParser interface {
	ParseString(s string) (err error)
}

type Strings 

type Strings struct{}

func (Strings) SQLType 

func (Strings) SQLType(dialect Dialector) string

func (Strings) Scaner 

func (Strings) Scaner(_ Dialector, dest reflect.Value) Scanner

func (Strings) Type 

func (Strings) Type() reflect.Type

func (Strings) Valuer 

func (Strings) Valuer(_ Dialector, value interface{}) driver.Valuer

type StructField 

type StructField struct {
	DBName          string
	Name            string
	Names           []string
	IsPrimaryKey    bool
	IsNormal        bool
	IsIgnored       bool
	IsScanner       bool
	IsReadOnly      bool
	HasDefaultValue bool
	Tag             reflect.StructTag
	TagSettings     TagSetting
	Struct          reflect.StructField
	BaseModel       *ModelStruct
	IsForeignKey    bool
	Relationship    *Relationship
	MethodCallbacks map[string]StructFieldMethodCallback
	StructIndex     []int
	Index           int
	Assigner        Assigner
	Data            map[interface{}]interface{}
	Selector        FieldSelector
	SelectWraper    FieldSelectWraper
}

StructField model field's struct definition

func (*StructField) CallMethodCallback 

func (this *StructField) CallMethodCallback(name string, object reflect.Value, in ...reflect.Value)

Call the method callback if exists by name. the

func (*StructField) CallMethodCallbackArgs 

func (this *StructField) CallMethodCallbackArgs(name string, object reflect.Value, in []reflect.Value)

Call the method callback if exists by name.

func (StructField) DefaultID 

func (this StructField) DefaultID() (IDValuer, error)

func (StructField) IDOf 

func (this StructField) IDOf(v interface{}) (IDValuer, error)

func (*StructField) Select 

func (this *StructField) Select(scope *Scope, tableName string) Query

func (*StructField) SelectWrap 

func (this *StructField) SelectWrap(scope *Scope, expr string) Query

func (*StructField) String 

func (this *StructField) String() string

func (*StructField) Structure 

func (this *StructField) Structure() *FieldStructure

type StructFieldMethodCallback 

type StructFieldMethodCallback struct {
	Method
	Caller reflect.Value
}

func (StructFieldMethodCallback) Call 

func (s StructFieldMethodCallback) Call(object reflect.Value, in []reflect.Value)

type StructFieldMethodCallbacksRegistrator 

type StructFieldMethodCallbacksRegistrator struct {
	Callbacks  map[string]reflect.Value
	FieldTypes safeEnabledFieldTypes
	// contains filtered or unexported fields
}

func NewStructFieldMethodCallbacksRegistrator 

func NewStructFieldMethodCallbacksRegistrator() *StructFieldMethodCallbacksRegistrator

func (*StructFieldMethodCallbacksRegistrator) DisableFieldType 

func (registrator *StructFieldMethodCallbacksRegistrator) DisableFieldType(typs ...interface{})

Disable all callbacks for field type

Example 
package main

import (
	"fmt"
)

func main() {
	fmt.Println(`if registrator.IsEnabledFieldType(&Media{}) {
	registrator.DisableFieldType(&Media{})
}`)
}

Output:

func (*StructFieldMethodCallbacksRegistrator) EnableFieldType 

func (registrator *StructFieldMethodCallbacksRegistrator) EnableFieldType(typs ...interface{})

Enable all callbacks for field type

Example 
package main

import (
	"fmt"
)

func main() {
	fmt.Println(`if !registrator.IsEnabledFieldType(&Media{}) {
	registrator.EnableFieldType(&Media{})
}`)
}

Output:

func (*StructFieldMethodCallbacksRegistrator) IsEnabledFieldType 

func (registrator *StructFieldMethodCallbacksRegistrator) IsEnabledFieldType(typ interface{}) bool

Return if all callbacks for field type is enabled

func (*StructFieldMethodCallbacksRegistrator) RegisterFieldType 

func (registrator *StructFieldMethodCallbacksRegistrator) RegisterFieldType(typs ...interface{})

Register new field type and enable all available callbacks for here

Example 
package main

import (
	"fmt"
)

func main() {
	fmt.Println("registrator.RegisterFieldType(&Media{})")
}

Output:

func (*StructFieldMethodCallbacksRegistrator) RegisteredFieldType 

func (registrator *StructFieldMethodCallbacksRegistrator) RegisteredFieldType(typ interface{}) bool

Return if field type is registered

Example 
package main

import (
	"fmt"
)

func main() {
	fmt.Println(`
if registrator.RegisteredFieldType(&Media{}) {
	println("not registered")
}`)
}

Output:

func (*StructFieldMethodCallbacksRegistrator) UnregisterFieldType 

func (registrator *StructFieldMethodCallbacksRegistrator) UnregisterFieldType(typ interface{}) (ok bool)

Unregister field type and return if ok

type StructFieldSetuper 

type StructFieldSetuper interface {
	AormStructFieldSetup(model *ModelStruct, field *StructField)
}

type StructIndex 

type StructIndex struct {
	Model         *ModelStruct
	Unique        bool
	NameTemplate  string
	Fields        []*StructField
	WhereTemplate string
	Where         string
}

func (*StructIndex) BuildName 

func (this *StructIndex) BuildName(d KeyNamer, tableName string) (name string)

func (*StructIndex) Columns 

func (this *StructIndex) Columns() []string

func (*StructIndex) FieldsNames 

func (this *StructIndex) FieldsNames() []string

func (*StructIndex) SqlCreate 

func (this *StructIndex) SqlCreate(d Dialector, tableName string) (sql string)

func (*StructIndex) SqlDrop 

func (this *StructIndex) SqlDrop(d interface {
	Quoter
	KeyNamer
}, tableName string) (sql string)

func (*StructIndex) String 

func (this *StructIndex) String() (s string)

type TableNamePlurabler 

type TableNamePlurabler interface {
	TableName(singular bool) string
}

type TableNameResolver 

type TableNameResolver interface {
	TableName(singular bool, value interface{}) (tableName string, ok bool)
}

func TableNameResolverOf 

func TableNameResolverOf(f func(singular bool, value interface{}) (tableName string, ok bool)) TableNameResolver

type TableNameResolverFunc 

type TableNameResolverFunc func(singular bool, value interface{}) (tableName string, ok bool)

func (TableNameResolverFunc) TableName 

func (this TableNameResolverFunc) TableName(singular bool, value interface{}) (tableName string, ok bool)

type TableNamer 

type TableNamer interface {
	TableName() string
}

type TagSetting 

type TagSetting map[string]string

func (TagSetting) Enable 

func (this TagSetting) Enable(key string)

func (TagSetting) Flag 

func (this TagSetting) Flag(name string) bool

func (TagSetting) Set 

func (this TagSetting) Set(key, value string)

func (TagSetting) Update 

func (this TagSetting) Update(setting ...map[string]string)

type Timestamper 

type Timestamper interface {
	GetCreatedAt() time.Time
	GetUpdatedAt() time.Time
}

type Timestamps 

type Timestamps struct {
	CreatedAt time.Time
	UpdatedAt time.Time
}

func (*Timestamps) GetCreatedAt 

func (t *Timestamps) GetCreatedAt() time.Time

func (*Timestamps) GetUpdatedAt 

func (t *Timestamps) GetUpdatedAt() time.Time

type ToVarsAppender 

type ToVarsAppender interface {
	AddToVars(value interface{}) (replacement string)
}

type UintId 

type UintId uint64

func (UintId) Bytes 

func (this UintId) Bytes() []byte

func (UintId) IsZero 

func (this UintId) IsZero() bool

func (UintId) ParseBytes 

func (UintId) ParseBytes(b []byte) (IDValuer, error)

func (UintId) ParseString 

func (UintId) ParseString(s string) (_ IDValuer, err error)

func (UintId) Raw 

func (this UintId) Raw() interface{}

func (UintId) String 

func (this UintId) String() string

func (UintId) Uint 

func (this UintId) Uint() uint64

type ValueScanner 

type ValueScanner struct {
	Field   *Field
	Typ     reflect.Type
	Data    interface{}
	NotNil  bool
	IsValid bool
	Ptr     bool
	Set     func(f *ValueScanner)
	MakePtr func() interface{}
}

func NewFieldScanner 

func NewFieldScanner(field *Field) *ValueScanner

func NewValueScanner 

func NewValueScanner(typ reflect.Type) *ValueScanner

func (*ValueScanner) IsNil 

func (f *ValueScanner) IsNil() bool

func (*ValueScanner) IsPtr 

func (f *ValueScanner) IsPtr() bool

func (*ValueScanner) Scan 

func (f *ValueScanner) Scan(src interface{}) error

type Vars 

type Vars []interface{}

type VirtualField 

type VirtualField struct {
	ModelStruct          *ModelStruct
	FieldName            string
	StructIndex          int
	Value                interface{}
	Options              map[interface{}]interface{}
	Setter               func(vf *VirtualField, recorde, value interface{})
	Getter               func(vf *VirtualField, recorde interface{}) (value interface{}, ok bool)
	LocalFieldName       string
	InlinePreloadOptions InlinePreloadOptions
}

func (*VirtualField) Get 

func (vf *VirtualField) Get(recorde interface{}) (value interface{}, ok bool)

func (*VirtualField) Set 

func (vf *VirtualField) Set(recorde, value interface{})

type VirtualFieldValue 

type VirtualFieldValue struct {
	Value interface{}
}

type VirtualFields 

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

func (*VirtualFields) GetVirtualField 

func (m *VirtualFields) GetVirtualField(fieldName string) (value interface{}, ok bool)

func (*VirtualFields) SetVirtualField 

func (m *VirtualFields) SetVirtualField(fieldName string, value interface{})

type VirtualFieldsGetter 

type VirtualFieldsGetter interface {
	GetVirtualField(fieldName string) (value interface{}, ok bool)
}

type VirtualFieldsSetter 

type VirtualFieldsSetter interface {
	SetVirtualField(fieldName string, value interface{})
}

type WhereClauser 

type WhereClauser interface {
	WhereClause(scope *Scope) (result Query)
}

type WithInlineQuery 

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

func IQ 

func IQ(query string, args ...interface{}) *WithInlineQuery

func (*WithInlineQuery) Paths 

func (iq *WithInlineQuery) Paths() []string

func (*WithInlineQuery) Query 

func (iq *WithInlineQuery) Query() string

func (*WithInlineQuery) String 

func (iq *WithInlineQuery) String() string

func (*WithInlineQuery) WhereClause 

func (iq *WithInlineQuery) WhereClause(scope *Scope) Query

type Zeroer 

type Zeroer interface {
	IsZero() bool
}

Source Files

View all Source files

Directories

Path Synopsis
dialects
mssql
mysql
postgres
sqlite

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.