README

xorm HAS BEEN MOVED TO https://gitea.com/xorm/xorm . THIS REPOSITORY WILL NOT BE UPDATED ANY MORE.

中文

Xorm is a simple and powerful ORM for Go.

CircleCI codecov

Features

  • Struct <-> Table Mapping Support

  • Chainable APIs

  • Transaction Support

  • Both ORM and raw SQL operation Support

  • Sync database schema Support

  • Query Cache speed up

  • Database Reverse support, See Xorm Tool README

  • Simple cascade loading support

  • Optimistic Locking support

  • SQL Builder support via xorm.io/builder

  • Automatical Read/Write seperatelly

  • Postgres schema support

  • Context Cache support

Drivers Support

Drivers for Go's sql package which currently support database/sql includes:

Installation

go get github.com/123jixinyu/xorm

Documents

Quick Start

  • Create Engine
engine, err := xorm.NewEngine(driverName, dataSourceName)
  • Define a struct and Sync2 table struct to database
type User struct {
    Id int64
    Name string
    Salt string
    Age int
    Passwd string `xorm:"varchar(200)"`
    Created time.Time `xorm:"created"`
    Updated time.Time `xorm:"updated"`
}

err := engine.Sync2(new(User))
  • Create Engine Group
dataSourceNameSlice := []string{masterDataSourceName, slave1DataSourceName, slave2DataSourceName}
engineGroup, err := xorm.NewEngineGroup(driverName, dataSourceNameSlice)
masterEngine, err := xorm.NewEngine(driverName, masterDataSourceName)
slave1Engine, err := xorm.NewEngine(driverName, slave1DataSourceName)
slave2Engine, err := xorm.NewEngine(driverName, slave2DataSourceName)
engineGroup, err := xorm.NewEngineGroup(masterEngine, []*Engine{slave1Engine, slave2Engine})

Then all place where engine you can just use engineGroup.

  • Query runs a SQL string, the returned results is []map[string][]byte, QueryString returns []map[string]string, QueryInterface returns []map[string]interface{}.
results, err := engine.Query("select * from user")
results, err := engine.Where("a = 1").Query()

results, err := engine.QueryString("select * from user")
results, err := engine.Where("a = 1").QueryString()

results, err := engine.QueryInterface("select * from user")
results, err := engine.Where("a = 1").QueryInterface()
  • Exec runs a SQL string, it returns affected and error
affected, err := engine.Exec("update user set age = ? where name = ?", age, name)
  • Insert one or multiple records to database
affected, err := engine.Insert(&user)
// INSERT INTO struct () values ()

affected, err := engine.Insert(&user1, &user2)
// INSERT INTO struct1 () values ()
// INSERT INTO struct2 () values ()

affected, err := engine.Insert(&users)
// INSERT INTO struct () values (),(),()

affected, err := engine.Insert(&user1, &users)
// INSERT INTO struct1 () values ()
// INSERT INTO struct2 () values (),(),()
  • Get query one record from database
has, err := engine.Get(&user)
// SELECT * FROM user LIMIT 1

has, err := engine.Where("name = ?", name).Desc("id").Get(&user)
// SELECT * FROM user WHERE name = ? ORDER BY id DESC LIMIT 1

var name string
has, err := engine.Table(&user).Where("id = ?", id).Cols("name").Get(&name)
// SELECT name FROM user WHERE id = ?

var id int64
has, err := engine.Table(&user).Where("name = ?", name).Cols("id").Get(&id)
has, err := engine.SQL("select id from user").Get(&id)
// SELECT id FROM user WHERE name = ?

var valuesMap = make(map[string]string)
has, err := engine.Table(&user).Where("id = ?", id).Get(&valuesMap)
// SELECT * FROM user WHERE id = ?

var valuesSlice = make([]interface{}, len(cols))
has, err := engine.Table(&user).Where("id = ?", id).Cols(cols...).Get(&valuesSlice)
// SELECT col1, col2, col3 FROM user WHERE id = ?
  • Exist check if one record exist on table
has, err := testEngine.Exist(new(RecordExist))
// SELECT * FROM record_exist LIMIT 1

has, err = testEngine.Exist(&RecordExist{
		Name: "test1",
	})
// SELECT * FROM record_exist WHERE name = ? LIMIT 1

has, err = testEngine.Where("name = ?", "test1").Exist(&RecordExist{})
// SELECT * FROM record_exist WHERE name = ? LIMIT 1

has, err = testEngine.SQL("select * from record_exist where name = ?", "test1").Exist()
// select * from record_exist where name = ?

has, err = testEngine.Table("record_exist").Exist()
// SELECT * FROM record_exist LIMIT 1

has, err = testEngine.Table("record_exist").Where("name = ?", "test1").Exist()
// SELECT * FROM record_exist WHERE name = ? LIMIT 1
  • Find query multiple records from database, also you can use join and extends
var users []User
err := engine.Where("name = ?", name).And("age > 10").Limit(10, 0).Find(&users)
// SELECT * FROM user WHERE name = ? AND age > 10 limit 10 offset 0

type Detail struct {
    Id int64
    UserId int64 `xorm:"index"`
}

type UserDetail struct {
    User `xorm:"extends"`
    Detail `xorm:"extends"`
}

var users []UserDetail
err := engine.Table("user").Select("user.*, detail.*").
    Join("INNER", "detail", "detail.user_id = user.id").
    Where("user.name = ?", name).Limit(10, 0).
    Find(&users)
// SELECT user.*, detail.* FROM user INNER JOIN detail WHERE user.name = ? limit 10 offset 0
  • Iterate and Rows query multiple records and record by record handle, there are two methods Iterate and Rows
err := engine.Iterate(&User{Name:name}, func(idx int, bean interface{}) error {
    user := bean.(*User)
    return nil
})
// SELECT * FROM user

err := engine.BufferSize(100).Iterate(&User{Name:name}, func(idx int, bean interface{}) error {
    user := bean.(*User)
    return nil
})
// SELECT * FROM user Limit 0, 100
// SELECT * FROM user Limit 101, 100

rows, err := engine.Rows(&User{Name:name})
// SELECT * FROM user
defer rows.Close()
bean := new(Struct)
for rows.Next() {
    err = rows.Scan(bean)
}
  • Update update one or more records, default will update non-empty and non-zero fields except when you use Cols, AllCols and so on.
affected, err := engine.ID(1).Update(&user)
// UPDATE user SET ... Where id = ?

affected, err := engine.Update(&user, &User{Name:name})
// UPDATE user SET ... Where name = ?

var ids = []int64{1, 2, 3}
affected, err := engine.In("id", ids).Update(&user)
// UPDATE user SET ... Where id IN (?, ?, ?)

// force update indicated columns by Cols
affected, err := engine.ID(1).Cols("age").Update(&User{Name:name, Age: 12})
// UPDATE user SET age = ?, updated=? Where id = ?

// force NOT update indicated columns by Omit
affected, err := engine.ID(1).Omit("name").Update(&User{Name:name, Age: 12})
// UPDATE user SET age = ?, updated=? Where id = ?

affected, err := engine.ID(1).AllCols().Update(&user)
// UPDATE user SET name=?,age=?,salt=?,passwd=?,updated=? Where id = ?
  • Delete delete one or more records, Delete MUST have condition
affected, err := engine.Where(...).Delete(&user)
// DELETE FROM user Where ...

affected, err := engine.ID(2).Delete(&user)
// DELETE FROM user Where id = ?
  • Count count records
counts, err := engine.Count(&user)
// SELECT count(*) AS total FROM user
  • FindAndCount combines function Find with Count which is usually used in query by page
var users []User
counts, err := engine.FindAndCount(&users)
  • Sum sum functions
agesFloat64, err := engine.Sum(&user, "age")
// SELECT sum(age) AS total FROM user

agesInt64, err := engine.SumInt(&user, "age")
// SELECT sum(age) AS total FROM user

sumFloat64Slice, err := engine.Sums(&user, "age", "score")
// SELECT sum(age), sum(score) FROM user

sumInt64Slice, err := engine.SumsInt(&user, "age", "score")
// SELECT sum(age), sum(score) FROM user
  • Query conditions builder
err := engine.Where(builder.NotIn("a", 1, 2).And(builder.In("b", "c", "d", "e"))).Find(&users)
// SELECT id, name ... FROM user WHERE a NOT IN (?, ?) AND b IN (?, ?, ?)
  • Multiple operations in one go routine, no transation here but resue session memory
session := engine.NewSession()
defer session.Close()

user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
if _, err := session.Insert(&user1); err != nil {
    return err
}

user2 := Userinfo{Username: "yyy"}
if _, err := session.Where("id = ?", 2).Update(&user2); err != nil {
    return err
}

if _, err := session.Exec("delete from userinfo where username = ?", user2.Username); err != nil {
    return err
}

return nil
  • Transation should on one go routine. There is transaction and resue session memory
session := engine.NewSession()
defer session.Close()

// add Begin() before any action
if err := session.Begin(); err != nil {
    // if returned then will rollback automatically
    return err
}

user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
if _, err := session.Insert(&user1); err != nil {
    return err
}

user2 := Userinfo{Username: "yyy"}
if _, err := session.Where("id = ?", 2).Update(&user2); err != nil {
    return err
}

if _, err := session.Exec("delete from userinfo where username = ?", user2.Username); err != nil {
    return err
}

// add Commit() after all actions
return session.Commit()
  • Or you can use Transaction to replace above codes.
res, err := engine.Transaction(func(session *xorm.Session) (interface{}, error) {
    user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
    if _, err := session.Insert(&user1); err != nil {
        return nil, err
    }

    user2 := Userinfo{Username: "yyy"}
    if _, err := session.Where("id = ?", 2).Update(&user2); err != nil {
        return nil, err
    }

    if _, err := session.Exec("delete from userinfo where username = ?", user2.Username); err != nil {
        return nil, err
    }
    return nil, nil
})
  • Context Cache, if enabled, current query result will be cached on session and be used by next same statement on the same session.
	sess := engine.NewSession()
	defer sess.Close()

	var context = xorm.NewMemoryContextCache()

	var c2 ContextGetStruct
	has, err := sess.ID(1).ContextCache(context).Get(&c2)
	assert.NoError(t, err)
	assert.True(t, has)
	assert.EqualValues(t, 1, c2.Id)
	assert.EqualValues(t, "1", c2.Name)
	sql, args := sess.LastSQL()
	assert.True(t, len(sql) > 0)
	assert.True(t, len(args) > 0)

	var c3 ContextGetStruct
	has, err = sess.ID(1).ContextCache(context).Get(&c3)
	assert.NoError(t, err)
	assert.True(t, has)
	assert.EqualValues(t, 1, c3.Id)
	assert.EqualValues(t, "1", c3.Name)
	sql, args = sess.LastSQL()
	assert.True(t, len(sql) == 0)
	assert.True(t, len(args) == 0)

Contributing

If you want to pull request, please see CONTRIBUTING. And we also provide Xorm on Google Groups to discuss.

Credits

Contributors

This project exists thanks to all the people who contribute. [Contribute].

Backers

Thank you to all our backers! 🙏 [Become a backer]

Sponsors

Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [Become a sponsor]

Changelog

  • v0.7.0

    • Some bugs fixed
  • v0.6.6

    • Some bugs fixed
  • v0.6.5

    • Postgres schema support
    • vgo support
    • Add FindAndCount
    • Database special params support via NewEngineWithParams
    • Some bugs fixed
  • v0.6.4

    • Automatical Read/Write seperatelly
    • Query/QueryString/QueryInterface and action with Where/And
    • Get support non-struct variables
    • BufferSize on Iterate
    • fix some other bugs.

More changes ...

Cases

LICENSE

BSD License http://creativecommons.org/licenses/BSD/

Documentation

Overview

Package xorm is a simple and powerful ORM for Go.

Installation

Make sure you have installed Go 1.6+ and then:

go get github.com/123jixinyu/xorm

Create Engine

Firstly, we should new an engine for a database

engine, err := xorm.NewEngine(driverName, dataSourceName)

Method NewEngine's parameters is the same as sql.Open. It depends drivers' implementation. Generally, one engine for an application is enough. You can set it as package variable.

Raw Methods

XORM also support raw SQL execution:

1. query a SQL string, the returned results is []map[string][]byte

results, err := engine.Query("select * from user")

2. execute a SQL string, the returned results

affected, err := engine.Exec("update user set .... where ...")

ORM Methods

There are 8 major ORM methods and many helpful methods to use to operate database.

1. Insert one or multiple records to database

affected, err := engine.Insert(&struct)
// INSERT INTO struct () values ()
affected, err := engine.Insert(&struct1, &struct2)
// INSERT INTO struct1 () values ()
// INSERT INTO struct2 () values ()
affected, err := engine.Insert(&sliceOfStruct)
// INSERT INTO struct () values (),(),()
affected, err := engine.Insert(&struct1, &sliceOfStruct2)
// INSERT INTO struct1 () values ()
// INSERT INTO struct2 () values (),(),()

2. Query one record or one variable from database

has, err := engine.Get(&user)
// SELECT * FROM user LIMIT 1

var id int64
has, err := engine.Table("user").Where("name = ?", name).Get(&id)
// SELECT id FROM user WHERE name = ? LIMIT 1

3. Query multiple records from database

var sliceOfStructs []Struct
err := engine.Find(&sliceOfStructs)
// SELECT * FROM user

var mapOfStructs = make(map[int64]Struct)
err := engine.Find(&mapOfStructs)
// SELECT * FROM user

var int64s []int64
err := engine.Table("user").Cols("id").Find(&int64s)
// SELECT id FROM user

4. Query multiple records and record by record handle, there two methods, one is Iterate, another is Rows

err := engine.Iterate(...)
// SELECT * FROM user

rows, err := engine.Rows(...)
// SELECT * FROM user
defer rows.Close()
bean := new(Struct)
for rows.Next() {
    err = rows.Scan(bean)
}

5. Update one or more records

affected, err := engine.ID(...).Update(&user)
// UPDATE user SET ...

6. Delete one or more records, Delete MUST has condition

affected, err := engine.Where(...).Delete(&user)
// DELETE FROM user Where ...

7. Count records

counts, err := engine.Count(&user)
// SELECT count(*) AS total FROM user

counts, err := engine.SQL("select count(*) FROM user").Count()
// select count(*) FROM user

8. Sum records

sumFloat64, err := engine.Sum(&user, "id")
// SELECT sum(id) from user

sumFloat64s, err := engine.Sums(&user, "id1", "id2")
// SELECT sum(id1), sum(id2) from user

sumInt64s, err := engine.SumsInt(&user, "id1", "id2")
// SELECT sum(id1), sum(id2) from user

Conditions

The above 8 methods could use with condition methods chainable. Attention: the above 8 methods should be the last chainable method.

1. ID, In

engine.ID(1).Get(&user) // for single primary key
// SELECT * FROM user WHERE id = 1
engine.ID(core.PK{1, 2}).Get(&user) // for composite primary keys
// SELECT * FROM user WHERE id1 = 1 AND id2 = 2
engine.In("id", 1, 2, 3).Find(&users)
// SELECT * FROM user WHERE id IN (1, 2, 3)
engine.In("id", []int{1, 2, 3}).Find(&users)
// SELECT * FROM user WHERE id IN (1, 2, 3)

2. Where, And, Or

engine.Where().And().Or().Find()
// SELECT * FROM user WHERE (.. AND ..) OR ...

3. OrderBy, Asc, Desc

engine.Asc().Desc().Find()
// SELECT * FROM user ORDER BY .. ASC, .. DESC
engine.OrderBy().Find()
// SELECT * FROM user ORDER BY ..

4. Limit, Top

engine.Limit().Find()
// SELECT * FROM user LIMIT .. OFFSET ..
engine.Top(5).Find()
// SELECT TOP 5 * FROM user // for mssql
// SELECT * FROM user LIMIT .. OFFSET 0 //for other databases

5. SQL, let you custom SQL

var users []User
engine.SQL("select * from user").Find(&users)

6. Cols, Omit, Distinct

var users []*User
engine.Cols("col1, col2").Find(&users)
// SELECT col1, col2 FROM user
engine.Cols("col1", "col2").Where().Update(user)
// UPDATE user set col1 = ?, col2 = ? Where ...
engine.Omit("col1").Find(&users)
// SELECT col2, col3 FROM user
engine.Omit("col1").Insert(&user)
// INSERT INTO table (non-col1) VALUES ()
engine.Distinct("col1").Find(&users)
// SELECT DISTINCT col1 FROM user

7. Join, GroupBy, Having

engine.GroupBy("name").Having("name='xlw'").Find(&users)
//SELECT * FROM user GROUP BY name HAVING name='xlw'
engine.Join("LEFT", "userdetail", "user.id=userdetail.id").Find(&users)
//SELECT * FROM user LEFT JOIN userdetail ON user.id=userdetail.id

More usage, please visit http://xorm.io/docs

Index

Constants

View Source
const (
	DEFAULT_LOG_PREFIX = "[xorm]"
	DEFAULT_LOG_FLAG   = log.Ldate | log.Lmicroseconds
	DEFAULT_LOG_LEVEL  = core.LOG_DEBUG
)

    default log options

    View Source
    const (
    	// Version show the xorm's version
    	Version string = "0.7.0.0504"
    )

    Variables

    View Source
    var (
    	// ErrParamsType params error
    	ErrParamsType = errors.New("Params type error")
    	// ErrTableNotFound table not found error
    	ErrTableNotFound = errors.New("Table not found")
    	// ErrUnSupportedType unsupported error
    	ErrUnSupportedType = errors.New("Unsupported type error")
    	// ErrNotExist record does not exist error
    	ErrNotExist = errors.New("Record does not exist")
    	// ErrCacheFailed cache failed error
    	ErrCacheFailed = errors.New("Cache failed")
    	// ErrNeedDeletedCond delete needs less one condition error
    	ErrNeedDeletedCond = errors.New("Delete action needs at least one condition")
    	// ErrNotImplemented not implemented
    	ErrNotImplemented = errors.New("Not implemented")
    	// ErrConditionType condition type unsupported
    	ErrConditionType = errors.New("Unsupported condition type")
    	// ErrUnSupportedSQLType parameter of SQL is not supported
    	ErrUnSupportedSQLType = errors.New("unsupported sql type")
    )
    View Source
    var (
    
    	// DefaultPostgresSchema default postgres schema
    	DefaultPostgresSchema = "public"
    )

      from http://www.postgresql.org/docs/current/static/sql-keywords-appendix.html

      Functions

      func AutoIncrTagHandler

      func AutoIncrTagHandler(ctx *tagContext) error

        AutoIncrTagHandler describes autoincr tag handler

        func CacheTagHandler

        func CacheTagHandler(ctx *tagContext) error

          CacheTagHandler describes cache tag handler

          func CommentTagHandler

          func CommentTagHandler(ctx *tagContext) error

            CommentTagHandler add comment to column

            func CreatedTagHandler

            func CreatedTagHandler(ctx *tagContext) error

              CreatedTagHandler describes created tag handler

              func DefaultTagHandler

              func DefaultTagHandler(ctx *tagContext) error

                DefaultTagHandler describes default tag handler

                func DeletedTagHandler

                func DeletedTagHandler(ctx *tagContext) error

                  DeletedTagHandler describes deleted tag handler

                  func ExtendsTagHandler

                  func ExtendsTagHandler(ctx *tagContext) error

                    ExtendsTagHandler describes extends tag handler

                    func IgnoreTagHandler

                    func IgnoreTagHandler(ctx *tagContext) error

                      IgnoreTagHandler describes ignored tag handler

                      func IndexTagHandler

                      func IndexTagHandler(ctx *tagContext) error

                        IndexTagHandler describes index tag handler

                        func LocalTagHandler

                        func LocalTagHandler(ctx *tagContext) error

                          LocalTagHandler describes local tag handler

                          func NULLTagHandler

                          func NULLTagHandler(ctx *tagContext) error

                            NULLTagHandler describes null tag handler

                            func NewMemoryContextCache

                            func NewMemoryContextCache() memoryContextCache

                              NewMemoryContextCache return memoryContextCache

                              func NoCacheTagHandler

                              func NoCacheTagHandler(ctx *tagContext) error

                                NoCacheTagHandler describes nocache tag handler

                                func NotNullTagHandler

                                func NotNullTagHandler(ctx *tagContext) error

                                  NotNullTagHandler describes notnull tag handler

                                  func OnlyFromDBTagHandler

                                  func OnlyFromDBTagHandler(ctx *tagContext) error

                                    OnlyFromDBTagHandler describes mapping direction tag handler

                                    func OnlyToDBTagHandler

                                    func OnlyToDBTagHandler(ctx *tagContext) error

                                      OnlyToDBTagHandler describes mapping direction tag handler

                                      func PKTagHandler

                                      func PKTagHandler(ctx *tagContext) error

                                        PKTagHandler decribes primary key tag handler

                                        func SQLTypeTagHandler

                                        func SQLTypeTagHandler(ctx *tagContext) error

                                          SQLTypeTagHandler describes SQL Type tag handler

                                          func UTCTagHandler

                                          func UTCTagHandler(ctx *tagContext) error

                                            UTCTagHandler describes utc tag handler

                                            func UniqueTagHandler

                                            func UniqueTagHandler(ctx *tagContext) error

                                              UniqueTagHandler describes unique tag handler

                                              func UpdatedTagHandler

                                              func UpdatedTagHandler(ctx *tagContext) error

                                                UpdatedTagHandler describes updated tag handler

                                                func VersionTagHandler

                                                func VersionTagHandler(ctx *tagContext) error

                                                  VersionTagHandler describes version tag handler

                                                  Types

                                                  type AfterDeleteProcessor

                                                  type AfterDeleteProcessor interface {
                                                  	AfterDelete()
                                                  }

                                                    AfterDeleteProcessor executed after an object has been deleted

                                                    type AfterInsertProcessor

                                                    type AfterInsertProcessor interface {
                                                    	AfterInsert()
                                                    }

                                                      AfterInsertProcessor executed after an object is persisted to the database

                                                      type AfterLoadProcessor

                                                      type AfterLoadProcessor interface {
                                                      	AfterLoad()
                                                      }

                                                        AfterLoadProcessor executed after an ojbect has been loaded from database

                                                        type AfterLoadSessionProcessor

                                                        type AfterLoadSessionProcessor interface {
                                                        	AfterLoad(*Session)
                                                        }

                                                          AfterLoadSessionProcessor executed after an ojbect has been loaded from database with session parameter

                                                          type AfterSetProcessor

                                                          type AfterSetProcessor interface {
                                                          	AfterSet(string, Cell)
                                                          }

                                                            AfterSetProcessor executed after data set to the struct fields

                                                            type AfterUpdateProcessor

                                                            type AfterUpdateProcessor interface {
                                                            	AfterUpdate()
                                                            }

                                                              AfterUpdateProcessor executed after an object has been updated

                                                              type BeforeDeleteProcessor

                                                              type BeforeDeleteProcessor interface {
                                                              	BeforeDelete()
                                                              }

                                                                BeforeDeleteProcessor executed before an object is deleted

                                                                type BeforeInsertProcessor

                                                                type BeforeInsertProcessor interface {
                                                                	BeforeInsert()
                                                                }

                                                                  BeforeInsertProcessor executed before an object is initially persisted to the database

                                                                  type BeforeSetProcessor

                                                                  type BeforeSetProcessor interface {
                                                                  	BeforeSet(string, Cell)
                                                                  }

                                                                    BeforeSetProcessor executed before data set to the struct fields

                                                                    type BeforeUpdateProcessor

                                                                    type BeforeUpdateProcessor interface {
                                                                    	BeforeUpdate()
                                                                    }

                                                                      BeforeUpdateProcessor executed before an object is updated

                                                                      type Cell

                                                                      type Cell *interface{}

                                                                        Cell cell is a result of one column field

                                                                        type ContextCache

                                                                        type ContextCache interface {
                                                                        	// Put puts value into cache with key.
                                                                        	Put(key string, val interface{})
                                                                        	// Get gets cached value by given key.
                                                                        	Get(key string) interface{}
                                                                        }

                                                                          ContextCache is the interface that operates the cache data.

                                                                          type DiscardLogger

                                                                          type DiscardLogger struct{}

                                                                            DiscardLogger don't log implementation for core.ILogger

                                                                            func (DiscardLogger) Debug

                                                                            func (DiscardLogger) Debug(v ...interface{})

                                                                              Debug empty implementation

                                                                              func (DiscardLogger) Debugf

                                                                              func (DiscardLogger) Debugf(format string, v ...interface{})

                                                                                Debugf empty implementation

                                                                                func (DiscardLogger) Error

                                                                                func (DiscardLogger) Error(v ...interface{})

                                                                                  Error empty implementation

                                                                                  func (DiscardLogger) Errorf

                                                                                  func (DiscardLogger) Errorf(format string, v ...interface{})

                                                                                    Errorf empty implementation

                                                                                    func (DiscardLogger) Info

                                                                                    func (DiscardLogger) Info(v ...interface{})

                                                                                      Info empty implementation

                                                                                      func (DiscardLogger) Infof

                                                                                      func (DiscardLogger) Infof(format string, v ...interface{})

                                                                                        Infof empty implementation

                                                                                        func (DiscardLogger) IsShowSQL

                                                                                        func (DiscardLogger) IsShowSQL() bool

                                                                                          IsShowSQL empty implementation

                                                                                          func (DiscardLogger) Level

                                                                                          func (DiscardLogger) Level() core.LogLevel

                                                                                            Level empty implementation

                                                                                            func (DiscardLogger) SetLevel

                                                                                            func (DiscardLogger) SetLevel(l core.LogLevel)

                                                                                              SetLevel empty implementation

                                                                                              func (DiscardLogger) ShowSQL

                                                                                              func (DiscardLogger) ShowSQL(show ...bool)

                                                                                                ShowSQL empty implementation

                                                                                                func (DiscardLogger) Warn

                                                                                                func (DiscardLogger) Warn(v ...interface{})

                                                                                                  Warn empty implementation

                                                                                                  func (DiscardLogger) Warnf

                                                                                                  func (DiscardLogger) Warnf(format string, v ...interface{})

                                                                                                    Warnf empty implementation

                                                                                                    type Engine

                                                                                                    type Engine struct {
                                                                                                    	ColumnMapper  core.IMapper
                                                                                                    	TableMapper   core.IMapper
                                                                                                    	TagIdentifier string
                                                                                                    	Tables        map[reflect.Type]*core.Table
                                                                                                    
                                                                                                    	Cacher core.Cacher
                                                                                                    
                                                                                                    	TZLocation *time.Location // The timezone of the application
                                                                                                    	DatabaseTZ *time.Location // The timezone of the database
                                                                                                    	// contains filtered or unexported fields
                                                                                                    }

                                                                                                      Engine is the major struct of xorm, it means a database manager. Commonly, an application only need one engine

                                                                                                      func NewEngine

                                                                                                      func NewEngine(driverName string, dataSourceName string) (*Engine, error)

                                                                                                        NewEngine new a db manager according to the parameter. Currently support four drivers

                                                                                                        func NewEngineWithParams

                                                                                                        func NewEngineWithParams(driverName string, dataSourceName string, params map[string]string) (*Engine, error)

                                                                                                          NewEngineWithParams new a db manager with params. The params will be passed to dialect.

                                                                                                          func (*Engine) After

                                                                                                          func (engine *Engine) After(closures func(interface{})) *Session

                                                                                                            After apply after insert Processor, affected bean is passed to closure arg

                                                                                                            func (*Engine) Alias

                                                                                                            func (engine *Engine) Alias(alias string) *Session

                                                                                                              Alias set the table alias

                                                                                                              func (*Engine) AllCols

                                                                                                              func (engine *Engine) AllCols() *Session

                                                                                                                AllCols indicates that all columns should be use

                                                                                                                func (*Engine) Asc

                                                                                                                func (engine *Engine) Asc(colNames ...string) *Session

                                                                                                                  Asc will generate "ORDER BY column1,column2 Asc" This method can chainable use.

                                                                                                                  engine.Desc("name").Asc("age").Find(&users)
                                                                                                                  // SELECT * FROM user ORDER BY name DESC, age ASC
                                                                                                                  

                                                                                                                  func (*Engine) AutoIncrStr

                                                                                                                  func (engine *Engine) AutoIncrStr() string

                                                                                                                    AutoIncrStr Database's autoincrement statement

                                                                                                                    func (*Engine) Before

                                                                                                                    func (engine *Engine) Before(closures func(interface{})) *Session

                                                                                                                      Before apply before Processor, affected bean is passed to closure arg

                                                                                                                      func (*Engine) BufferSize

                                                                                                                      func (engine *Engine) BufferSize(size int) *Session

                                                                                                                        BufferSize sets buffer size for iterate

                                                                                                                        func (*Engine) Cascade

                                                                                                                        func (engine *Engine) Cascade(trueOrFalse ...bool) *Session

                                                                                                                          Cascade use cascade or not

                                                                                                                          func (*Engine) Charset

                                                                                                                          func (engine *Engine) Charset(charset string) *Session

                                                                                                                            Charset set charset when create table, only support mysql now

                                                                                                                            func (*Engine) ClearCache

                                                                                                                            func (engine *Engine) ClearCache(beans ...interface{}) error

                                                                                                                              ClearCache if enabled cache, clear some tables' cache

                                                                                                                              func (*Engine) ClearCacheBean

                                                                                                                              func (engine *Engine) ClearCacheBean(bean interface{}, id string) error

                                                                                                                                ClearCacheBean if enabled cache, clear the cache bean

                                                                                                                                func (*Engine) Clone

                                                                                                                                func (engine *Engine) Clone() (*Engine, error)

                                                                                                                                  Clone clone an engine

                                                                                                                                  func (*Engine) Close

                                                                                                                                  func (engine *Engine) Close() error

                                                                                                                                    Close the engine

                                                                                                                                    func (*Engine) Cols

                                                                                                                                    func (engine *Engine) Cols(columns ...string) *Session

                                                                                                                                      Cols only use the parameters as select or update columns

                                                                                                                                      func (*Engine) CondDeleted

                                                                                                                                      func (engine *Engine) CondDeleted(colName string) builder.Cond

                                                                                                                                        CondDeleted returns the conditions whether a record is soft deleted.

                                                                                                                                        func (*Engine) Context

                                                                                                                                        func (engine *Engine) Context(ctx context.Context) *Session

                                                                                                                                          Context creates a session with the context

                                                                                                                                          func (*Engine) Count

                                                                                                                                          func (engine *Engine) Count(bean ...interface{}) (int64, error)

                                                                                                                                            Count counts the records. bean's non-empty fields are conditions.

                                                                                                                                            func (*Engine) CreateIndexes

                                                                                                                                            func (engine *Engine) CreateIndexes(bean interface{}) error

                                                                                                                                              CreateIndexes create indexes

                                                                                                                                              func (*Engine) CreateTables

                                                                                                                                              func (engine *Engine) CreateTables(beans ...interface{}) error

                                                                                                                                                CreateTables create tabls according bean

                                                                                                                                                func (*Engine) CreateUniques

                                                                                                                                                func (engine *Engine) CreateUniques(bean interface{}) error

                                                                                                                                                  CreateUniques create uniques

                                                                                                                                                  func (*Engine) DB

                                                                                                                                                  func (engine *Engine) DB() *core.DB

                                                                                                                                                    DB return the wrapper of sql.DB

                                                                                                                                                    func (*Engine) DBMetas

                                                                                                                                                    func (engine *Engine) DBMetas() ([]*core.Table, error)

                                                                                                                                                      DBMetas Retrieve all tables, columns, indexes' informations from database.

                                                                                                                                                      func (*Engine) DataSourceName

                                                                                                                                                      func (engine *Engine) DataSourceName() string

                                                                                                                                                        DataSourceName return the current connection string

                                                                                                                                                        func (*Engine) Decr

                                                                                                                                                        func (engine *Engine) Decr(column string, arg ...interface{}) *Session

                                                                                                                                                          Decr provides a update string like "column = column - ?"

                                                                                                                                                          func (*Engine) Delete

                                                                                                                                                          func (engine *Engine) Delete(bean interface{}) (int64, error)

                                                                                                                                                            Delete records, bean's non-empty fields are conditions

                                                                                                                                                            func (*Engine) Desc

                                                                                                                                                            func (engine *Engine) Desc(colNames ...string) *Session

                                                                                                                                                              Desc will generate "ORDER BY column1 DESC, column2 DESC"

                                                                                                                                                              func (*Engine) Dialect

                                                                                                                                                              func (engine *Engine) Dialect() core.Dialect

                                                                                                                                                                Dialect return database dialect

                                                                                                                                                                func (*Engine) Distinct

                                                                                                                                                                func (engine *Engine) Distinct(columns ...string) *Session

                                                                                                                                                                  Distinct use for distinct columns. Caution: when you are using cache, distinct will not be cached because cache system need id, but distinct will not provide id

                                                                                                                                                                  func (*Engine) DriverName

                                                                                                                                                                  func (engine *Engine) DriverName() string

                                                                                                                                                                    DriverName return the current sql driver's name

                                                                                                                                                                    func (*Engine) DropIndexes

                                                                                                                                                                    func (engine *Engine) DropIndexes(bean interface{}) error

                                                                                                                                                                      DropIndexes drop indexes of a table

                                                                                                                                                                      func (*Engine) DropTables

                                                                                                                                                                      func (engine *Engine) DropTables(beans ...interface{}) error

                                                                                                                                                                        DropTables drop specify tables

                                                                                                                                                                        func (*Engine) DumpAll

                                                                                                                                                                        func (engine *Engine) DumpAll(w io.Writer, tp ...core.DbType) error

                                                                                                                                                                          DumpAll dump database all table structs and data to w

                                                                                                                                                                          func (*Engine) DumpAllToFile

                                                                                                                                                                          func (engine *Engine) DumpAllToFile(fp string, tp ...core.DbType) error

                                                                                                                                                                            DumpAllToFile dump database all table structs and data to a file

                                                                                                                                                                            func (*Engine) DumpTables

                                                                                                                                                                            func (engine *Engine) DumpTables(tables []*core.Table, w io.Writer, tp ...core.DbType) error

                                                                                                                                                                              DumpTables dump specify tables to io.Writer

                                                                                                                                                                              func (*Engine) DumpTablesToFile

                                                                                                                                                                              func (engine *Engine) DumpTablesToFile(tables []*core.Table, fp string, tp ...core.DbType) error

                                                                                                                                                                                DumpTablesToFile dump specified tables to SQL file.

                                                                                                                                                                                func (*Engine) Exec

                                                                                                                                                                                func (engine *Engine) Exec(sqlOrArgs ...interface{}) (sql.Result, error)

                                                                                                                                                                                  Exec raw sql

                                                                                                                                                                                  func (*Engine) Exist

                                                                                                                                                                                  func (engine *Engine) Exist(bean ...interface{}) (bool, error)

                                                                                                                                                                                    Exist returns true if the record exist otherwise return false

                                                                                                                                                                                    func (*Engine) Find

                                                                                                                                                                                    func (engine *Engine) Find(beans interface{}, condiBeans ...interface{}) error

                                                                                                                                                                                      Find retrieve records from table, condiBeans's non-empty fields are conditions. beans could be []Struct, []*Struct, map[int64]Struct map[int64]*Struct

                                                                                                                                                                                      func (*Engine) FindAndCount

                                                                                                                                                                                      func (engine *Engine) FindAndCount(rowsSlicePtr interface{}, condiBean ...interface{}) (int64, error)

                                                                                                                                                                                        FindAndCount find the results and also return the counts

                                                                                                                                                                                        func (*Engine) Get

                                                                                                                                                                                        func (engine *Engine) Get(bean interface{}) (bool, error)

                                                                                                                                                                                          Get retrieve one record from table, bean's non-empty fields are conditions

                                                                                                                                                                                          func (*Engine) GetCacher

                                                                                                                                                                                          func (engine *Engine) GetCacher(tableName string) core.Cacher

                                                                                                                                                                                          func (*Engine) GetColumnMapper

                                                                                                                                                                                          func (engine *Engine) GetColumnMapper() core.IMapper

                                                                                                                                                                                            GetColumnMapper returns the column name mapper

                                                                                                                                                                                            func (*Engine) GetDefaultCacher

                                                                                                                                                                                            func (engine *Engine) GetDefaultCacher() core.Cacher

                                                                                                                                                                                              GetDefaultCacher returns the default cacher

                                                                                                                                                                                              func (*Engine) GetTZDatabase

                                                                                                                                                                                              func (engine *Engine) GetTZDatabase() *time.Location

                                                                                                                                                                                                GetTZDatabase returns time zone of the database

                                                                                                                                                                                                func (*Engine) GetTZLocation

                                                                                                                                                                                                func (engine *Engine) GetTZLocation() *time.Location

                                                                                                                                                                                                  GetTZLocation returns time zone of the application

                                                                                                                                                                                                  func (*Engine) GetTableMapper

                                                                                                                                                                                                  func (engine *Engine) GetTableMapper() core.IMapper

                                                                                                                                                                                                    GetTableMapper returns the table name mapper

                                                                                                                                                                                                    func (*Engine) GobRegister

                                                                                                                                                                                                    func (engine *Engine) GobRegister(v interface{}) *Engine

                                                                                                                                                                                                      GobRegister register one struct to gob for cache use

                                                                                                                                                                                                      func (*Engine) GroupBy

                                                                                                                                                                                                      func (engine *Engine) GroupBy(keys string) *Session

                                                                                                                                                                                                        GroupBy generate group by statement

                                                                                                                                                                                                        func (*Engine) Having

                                                                                                                                                                                                        func (engine *Engine) Having(conditions string) *Session

                                                                                                                                                                                                          Having generate having statement

                                                                                                                                                                                                          func (*Engine) ID

                                                                                                                                                                                                          func (engine *Engine) ID(id interface{}) *Session

                                                                                                                                                                                                            ID method provoide a condition as (id) = ?

                                                                                                                                                                                                            func (*Engine) IDOf

                                                                                                                                                                                                            func (engine *Engine) IDOf(bean interface{}) core.PK

                                                                                                                                                                                                              IDOf get id from one struct

                                                                                                                                                                                                              func (*Engine) IDOfV

                                                                                                                                                                                                              func (engine *Engine) IDOfV(rv reflect.Value) core.PK

                                                                                                                                                                                                                IDOfV get id from one value of struct

                                                                                                                                                                                                                func (*Engine) Id

                                                                                                                                                                                                                func (engine *Engine) Id(id interface{}) *Session

                                                                                                                                                                                                                  Id will be deprecated, please use ID instead

                                                                                                                                                                                                                  func (*Engine) IdOf

                                                                                                                                                                                                                  func (engine *Engine) IdOf(bean interface{}) core.PK

                                                                                                                                                                                                                    IdOf get id from one struct

                                                                                                                                                                                                                    Deprecated: use IDOf instead.

                                                                                                                                                                                                                    func (*Engine) IdOfV

                                                                                                                                                                                                                    func (engine *Engine) IdOfV(rv reflect.Value) core.PK

                                                                                                                                                                                                                      IdOfV get id from one value of struct

                                                                                                                                                                                                                      Deprecated: use IDOfV instead.

                                                                                                                                                                                                                      func (*Engine) Import

                                                                                                                                                                                                                      func (engine *Engine) Import(r io.Reader) ([]sql.Result, error)

                                                                                                                                                                                                                        Import SQL DDL from io.Reader

                                                                                                                                                                                                                        func (*Engine) ImportFile

                                                                                                                                                                                                                        func (engine *Engine) ImportFile(ddlPath string) ([]sql.Result, error)

                                                                                                                                                                                                                          ImportFile SQL DDL file

                                                                                                                                                                                                                          func (*Engine) In

                                                                                                                                                                                                                          func (engine *Engine) In(column string, args ...interface{}) *Session

                                                                                                                                                                                                                            In will generate "column IN (?, ?)"

                                                                                                                                                                                                                            func (*Engine) Incr

                                                                                                                                                                                                                            func (engine *Engine) Incr(column string, arg ...interface{}) *Session

                                                                                                                                                                                                                              Incr provides a update string like "column = column + ?"

                                                                                                                                                                                                                              func (*Engine) Insert

                                                                                                                                                                                                                              func (engine *Engine) Insert(beans ...interface{}) (int64, error)

                                                                                                                                                                                                                                Insert one or more records

                                                                                                                                                                                                                                func (*Engine) InsertOne

                                                                                                                                                                                                                                func (engine *Engine) InsertOne(bean interface{}) (int64, error)

                                                                                                                                                                                                                                  InsertOne insert only one record

                                                                                                                                                                                                                                  func (*Engine) IsTableEmpty

                                                                                                                                                                                                                                  func (engine *Engine) IsTableEmpty(bean interface{}) (bool, error)

                                                                                                                                                                                                                                    IsTableEmpty if a table has any reocrd

                                                                                                                                                                                                                                    func (*Engine) IsTableExist

                                                                                                                                                                                                                                    func (engine *Engine) IsTableExist(beanOrTableName interface{}) (bool, error)

                                                                                                                                                                                                                                      IsTableExist if a table is exist

                                                                                                                                                                                                                                      func (*Engine) Iterate

                                                                                                                                                                                                                                      func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error

                                                                                                                                                                                                                                        Iterate record by record handle records from table, bean's non-empty fields are conditions.

                                                                                                                                                                                                                                        func (*Engine) Join

                                                                                                                                                                                                                                        func (engine *Engine) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session

                                                                                                                                                                                                                                          Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN

                                                                                                                                                                                                                                          func (*Engine) Limit

                                                                                                                                                                                                                                          func (engine *Engine) Limit(limit int, start ...int) *Session

                                                                                                                                                                                                                                            Limit will generate "LIMIT start, limit"

                                                                                                                                                                                                                                            func (*Engine) Logger

                                                                                                                                                                                                                                            func (engine *Engine) Logger() core.ILogger

                                                                                                                                                                                                                                              Logger return the logger interface

                                                                                                                                                                                                                                              func (*Engine) MapCacher

                                                                                                                                                                                                                                              func (engine *Engine) MapCacher(bean interface{}, cacher core.Cacher) error

                                                                                                                                                                                                                                                MapCacher Set a table use a special cacher

                                                                                                                                                                                                                                                func (*Engine) MustCols

                                                                                                                                                                                                                                                func (engine *Engine) MustCols(columns ...string) *Session

                                                                                                                                                                                                                                                  MustCols specify some columns must use even if they are empty

                                                                                                                                                                                                                                                  func (*Engine) NewDB

                                                                                                                                                                                                                                                  func (engine *Engine) NewDB() (*core.DB, error)

                                                                                                                                                                                                                                                    NewDB provides an interface to operate database directly

                                                                                                                                                                                                                                                    func (*Engine) NewSession

                                                                                                                                                                                                                                                    func (engine *Engine) NewSession() *Session

                                                                                                                                                                                                                                                      NewSession New a session

                                                                                                                                                                                                                                                      func (*Engine) NoAutoCondition

                                                                                                                                                                                                                                                      func (engine *Engine) NoAutoCondition(no ...bool) *Session

                                                                                                                                                                                                                                                        NoAutoCondition disable auto generate Where condition from bean or not

                                                                                                                                                                                                                                                        func (*Engine) NoAutoTime

                                                                                                                                                                                                                                                        func (engine *Engine) NoAutoTime() *Session

                                                                                                                                                                                                                                                          NoAutoTime Default if your struct has "created" or "updated" filed tag, the fields will automatically be filled with current time when Insert or Update invoked. Call NoAutoTime if you dont' want to fill automatically.

                                                                                                                                                                                                                                                          func (*Engine) NoCache

                                                                                                                                                                                                                                                          func (engine *Engine) NoCache() *Session

                                                                                                                                                                                                                                                            NoCache If you has set default cacher, and you want temporilly stop use cache, you can use NoCache()

                                                                                                                                                                                                                                                            func (*Engine) NoCascade

                                                                                                                                                                                                                                                            func (engine *Engine) NoCascade() *Session

                                                                                                                                                                                                                                                              NoCascade If you do not want to auto cascade load object

                                                                                                                                                                                                                                                              func (*Engine) NotIn

                                                                                                                                                                                                                                                              func (engine *Engine) NotIn(column string, args ...interface{}) *Session

                                                                                                                                                                                                                                                                NotIn will generate "column NOT IN (?, ?)"

                                                                                                                                                                                                                                                                func (*Engine) Nullable

                                                                                                                                                                                                                                                                func (engine *Engine) Nullable(columns ...string) *Session

                                                                                                                                                                                                                                                                  Nullable set null when column is zero-value and nullable for update

                                                                                                                                                                                                                                                                  func (*Engine) Omit

                                                                                                                                                                                                                                                                  func (engine *Engine) Omit(columns ...string) *Session

                                                                                                                                                                                                                                                                    Omit only not use the parameters as select or update columns

                                                                                                                                                                                                                                                                    func (*Engine) OrderBy

                                                                                                                                                                                                                                                                    func (engine *Engine) OrderBy(order string) *Session

                                                                                                                                                                                                                                                                      OrderBy will generate "ORDER BY order"

                                                                                                                                                                                                                                                                      func (*Engine) Ping

                                                                                                                                                                                                                                                                      func (engine *Engine) Ping() error

                                                                                                                                                                                                                                                                        Ping tests if database is alive

                                                                                                                                                                                                                                                                        func (*Engine) PingContext

                                                                                                                                                                                                                                                                        func (engine *Engine) PingContext(ctx context.Context) error

                                                                                                                                                                                                                                                                          PingContext tests if database is alive

                                                                                                                                                                                                                                                                          func (*Engine) Prepare

                                                                                                                                                                                                                                                                          func (engine *Engine) Prepare() *Session

                                                                                                                                                                                                                                                                            Prepare enables prepare statement

                                                                                                                                                                                                                                                                            func (*Engine) Query

                                                                                                                                                                                                                                                                            func (engine *Engine) Query(sqlOrArgs ...interface{}) (resultsSlice []map[string][]byte, err error)

                                                                                                                                                                                                                                                                              Query a raw sql and return records as []map[string][]byte

                                                                                                                                                                                                                                                                              func (*Engine) QueryInterface

                                                                                                                                                                                                                                                                              func (engine *Engine) QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                                                                                                                                QueryInterface runs a raw sql and return records as []map[string]interface{}

                                                                                                                                                                                                                                                                                func (*Engine) QueryString

                                                                                                                                                                                                                                                                                func (engine *Engine) QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error)

                                                                                                                                                                                                                                                                                  QueryString runs a raw sql and return records as []map[string]string

                                                                                                                                                                                                                                                                                  func (*Engine) Quote

                                                                                                                                                                                                                                                                                  func (engine *Engine) Quote(value string) string

                                                                                                                                                                                                                                                                                    Quote Use QuoteStr quote the string sql

                                                                                                                                                                                                                                                                                    func (*Engine) QuoteTo

                                                                                                                                                                                                                                                                                    func (engine *Engine) QuoteTo(buf *strings.Builder, value string)

                                                                                                                                                                                                                                                                                      QuoteTo quotes string and writes into the buffer

                                                                                                                                                                                                                                                                                      func (*Engine) Rows

                                                                                                                                                                                                                                                                                      func (engine *Engine) Rows(bean interface{}) (*Rows, error)

                                                                                                                                                                                                                                                                                        Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                        func (*Engine) SQL

                                                                                                                                                                                                                                                                                        func (engine *Engine) SQL(query interface{}, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                          SQL method let's you manually write raw SQL and operate For example:

                                                                                                                                                                                                                                                                                          engine.SQL("select * from user").Find(&users)
                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                          This code will execute "select * from user" and set the records to users

                                                                                                                                                                                                                                                                                          func (*Engine) SQLType

                                                                                                                                                                                                                                                                                          func (engine *Engine) SQLType(c *core.Column) string

                                                                                                                                                                                                                                                                                            SQLType A simple wrapper to dialect's core.SqlType method

                                                                                                                                                                                                                                                                                            func (*Engine) Select

                                                                                                                                                                                                                                                                                            func (engine *Engine) Select(str string) *Session

                                                                                                                                                                                                                                                                                              Select customerize your select columns or contents

                                                                                                                                                                                                                                                                                              func (*Engine) SetCacher

                                                                                                                                                                                                                                                                                              func (engine *Engine) SetCacher(tableName string, cacher core.Cacher)

                                                                                                                                                                                                                                                                                              func (*Engine) SetColumnMapper

                                                                                                                                                                                                                                                                                              func (engine *Engine) SetColumnMapper(mapper core.IMapper)

                                                                                                                                                                                                                                                                                                SetColumnMapper set the column name mapping rule

                                                                                                                                                                                                                                                                                                func (*Engine) SetConnMaxLifetime

                                                                                                                                                                                                                                                                                                func (engine *Engine) SetConnMaxLifetime(d time.Duration)

                                                                                                                                                                                                                                                                                                  SetConnMaxLifetime sets the maximum amount of time a connection may be reused.

                                                                                                                                                                                                                                                                                                  func (*Engine) SetDefaultCacher

                                                                                                                                                                                                                                                                                                  func (engine *Engine) SetDefaultCacher(cacher core.Cacher)

                                                                                                                                                                                                                                                                                                    SetDefaultCacher set the default cacher. Xorm's default not enable cacher.

                                                                                                                                                                                                                                                                                                    func (*Engine) SetDefaultContext

                                                                                                                                                                                                                                                                                                    func (engine *Engine) SetDefaultContext(ctx context.Context)

                                                                                                                                                                                                                                                                                                      SetDefaultContext set the default context

                                                                                                                                                                                                                                                                                                      func (*Engine) SetDisableGlobalCache

                                                                                                                                                                                                                                                                                                      func (engine *Engine) SetDisableGlobalCache(disable bool)

                                                                                                                                                                                                                                                                                                        SetDisableGlobalCache disable global cache or not

                                                                                                                                                                                                                                                                                                        func (*Engine) SetExpr

                                                                                                                                                                                                                                                                                                        func (engine *Engine) SetExpr(column string, expression interface{}) *Session

                                                                                                                                                                                                                                                                                                          SetExpr provides a update string like "column = {expression}"

                                                                                                                                                                                                                                                                                                          func (*Engine) SetLogLevel

                                                                                                                                                                                                                                                                                                          func (engine *Engine) SetLogLevel(level core.LogLevel)

                                                                                                                                                                                                                                                                                                            SetLogLevel sets the logger level

                                                                                                                                                                                                                                                                                                            func (*Engine) SetLogger

                                                                                                                                                                                                                                                                                                            func (engine *Engine) SetLogger(logger core.ILogger)

                                                                                                                                                                                                                                                                                                              SetLogger set the new logger

                                                                                                                                                                                                                                                                                                              func (*Engine) SetMapper

                                                                                                                                                                                                                                                                                                              func (engine *Engine) SetMapper(mapper core.IMapper)

                                                                                                                                                                                                                                                                                                                SetMapper set the name mapping rules

                                                                                                                                                                                                                                                                                                                func (*Engine) SetMaxIdleConns

                                                                                                                                                                                                                                                                                                                func (engine *Engine) SetMaxIdleConns(conns int)

                                                                                                                                                                                                                                                                                                                  SetMaxIdleConns set the max idle connections on pool, default is 2

                                                                                                                                                                                                                                                                                                                  func (*Engine) SetMaxOpenConns

                                                                                                                                                                                                                                                                                                                  func (engine *Engine) SetMaxOpenConns(conns int)

                                                                                                                                                                                                                                                                                                                    SetMaxOpenConns is only available for go 1.2+

                                                                                                                                                                                                                                                                                                                    func (*Engine) SetSchema

                                                                                                                                                                                                                                                                                                                    func (engine *Engine) SetSchema(schema string)

                                                                                                                                                                                                                                                                                                                      SetSchema sets the schema of database

                                                                                                                                                                                                                                                                                                                      func (*Engine) SetTZDatabase

                                                                                                                                                                                                                                                                                                                      func (engine *Engine) SetTZDatabase(tz *time.Location)

                                                                                                                                                                                                                                                                                                                        SetTZDatabase sets time zone of the database

                                                                                                                                                                                                                                                                                                                        func (*Engine) SetTZLocation

                                                                                                                                                                                                                                                                                                                        func (engine *Engine) SetTZLocation(tz *time.Location)

                                                                                                                                                                                                                                                                                                                          SetTZLocation sets time zone of the application

                                                                                                                                                                                                                                                                                                                          func (*Engine) SetTableMapper

                                                                                                                                                                                                                                                                                                                          func (engine *Engine) SetTableMapper(mapper core.IMapper)

                                                                                                                                                                                                                                                                                                                            SetTableMapper set the table name mapping rule

                                                                                                                                                                                                                                                                                                                            func (*Engine) ShowExecTime

                                                                                                                                                                                                                                                                                                                            func (engine *Engine) ShowExecTime(show ...bool)

                                                                                                                                                                                                                                                                                                                              ShowExecTime show SQL statement and execute time or not on logger if log level is great than INFO

                                                                                                                                                                                                                                                                                                                              func (*Engine) ShowSQL

                                                                                                                                                                                                                                                                                                                              func (engine *Engine) ShowSQL(show ...bool)

                                                                                                                                                                                                                                                                                                                                ShowSQL show SQL statement or not on logger if log level is great than INFO

                                                                                                                                                                                                                                                                                                                                func (*Engine) Sql

                                                                                                                                                                                                                                                                                                                                func (engine *Engine) Sql(querystring string, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                  Sql provides raw sql input parameter. When you have a complex SQL statement and cannot use Where, Id, In and etc. Methods to describe, you can use SQL.

                                                                                                                                                                                                                                                                                                                                  Deprecated: use SQL instead.

                                                                                                                                                                                                                                                                                                                                  func (*Engine) SqlType

                                                                                                                                                                                                                                                                                                                                  func (engine *Engine) SqlType(c *core.Column) string

                                                                                                                                                                                                                                                                                                                                    SqlType will be deprecated, please use SQLType instead

                                                                                                                                                                                                                                                                                                                                    Deprecated: use SQLType instead

                                                                                                                                                                                                                                                                                                                                    func (*Engine) StoreEngine

                                                                                                                                                                                                                                                                                                                                    func (engine *Engine) StoreEngine(storeEngine string) *Session

                                                                                                                                                                                                                                                                                                                                      StoreEngine set store engine when create table, only support mysql now

                                                                                                                                                                                                                                                                                                                                      func (*Engine) Sum

                                                                                                                                                                                                                                                                                                                                      func (engine *Engine) Sum(bean interface{}, colName string) (float64, error)

                                                                                                                                                                                                                                                                                                                                        Sum sum the records by some column. bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                                                                        func (*Engine) SumInt

                                                                                                                                                                                                                                                                                                                                        func (engine *Engine) SumInt(bean interface{}, colName string) (int64, error)

                                                                                                                                                                                                                                                                                                                                          SumInt sum the records by some column. bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                                                                          func (*Engine) Sums

                                                                                                                                                                                                                                                                                                                                          func (engine *Engine) Sums(bean interface{}, colNames ...string) ([]float64, error)

                                                                                                                                                                                                                                                                                                                                            Sums sum the records by some columns. bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                                                                            func (*Engine) SumsInt

                                                                                                                                                                                                                                                                                                                                            func (engine *Engine) SumsInt(bean interface{}, colNames ...string) ([]int64, error)

                                                                                                                                                                                                                                                                                                                                              SumsInt like Sums but return slice of int64 instead of float64.

                                                                                                                                                                                                                                                                                                                                              func (*Engine) SupportInsertMany

                                                                                                                                                                                                                                                                                                                                              func (engine *Engine) SupportInsertMany() bool

                                                                                                                                                                                                                                                                                                                                                SupportInsertMany If engine's database support batch insert records like "insert into user values (name, age), (name, age)". When the return is ture, then engine.Insert(&users) will generate batch sql and exeute.

                                                                                                                                                                                                                                                                                                                                                func (*Engine) Sync

                                                                                                                                                                                                                                                                                                                                                func (engine *Engine) Sync(beans ...interface{}) error

                                                                                                                                                                                                                                                                                                                                                  Sync the new struct changes to database, this method will automatically add table, column, index, unique. but will not delete or change anything. If you change some field, you should change the database manually.

                                                                                                                                                                                                                                                                                                                                                  func (*Engine) Sync2

                                                                                                                                                                                                                                                                                                                                                  func (engine *Engine) Sync2(beans ...interface{}) error

                                                                                                                                                                                                                                                                                                                                                    Sync2 synchronize structs to database tables

                                                                                                                                                                                                                                                                                                                                                    func (*Engine) Table

                                                                                                                                                                                                                                                                                                                                                    func (engine *Engine) Table(tableNameOrBean interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                      Table temporarily change the Get, Find, Update's table

                                                                                                                                                                                                                                                                                                                                                      func (*Engine) TableInfo

                                                                                                                                                                                                                                                                                                                                                      func (engine *Engine) TableInfo(bean interface{}) *Table

                                                                                                                                                                                                                                                                                                                                                        TableInfo get table info according to bean's content

                                                                                                                                                                                                                                                                                                                                                        func (*Engine) TableName

                                                                                                                                                                                                                                                                                                                                                        func (engine *Engine) TableName(bean interface{}, includeSchema ...bool) string

                                                                                                                                                                                                                                                                                                                                                          TableName returns table name with schema prefix if has

                                                                                                                                                                                                                                                                                                                                                          func (*Engine) Transaction

                                                                                                                                                                                                                                                                                                                                                          func (engine *Engine) Transaction(f func(*Session) (interface{}, error)) (interface{}, error)

                                                                                                                                                                                                                                                                                                                                                            Transaction Execute sql wrapped in a transaction(abbr as tx), tx will automatic commit if no errors occurred

                                                                                                                                                                                                                                                                                                                                                            func (*Engine) UnMapType

                                                                                                                                                                                                                                                                                                                                                            func (engine *Engine) UnMapType(t reflect.Type)

                                                                                                                                                                                                                                                                                                                                                              UnMapType removes the datbase mapper of a type

                                                                                                                                                                                                                                                                                                                                                              func (*Engine) Unscoped

                                                                                                                                                                                                                                                                                                                                                              func (engine *Engine) Unscoped() *Session

                                                                                                                                                                                                                                                                                                                                                                Unscoped always disable struct tag "deleted"

                                                                                                                                                                                                                                                                                                                                                                func (*Engine) Update

                                                                                                                                                                                                                                                                                                                                                                func (engine *Engine) Update(bean interface{}, condiBeans ...interface{}) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                  Update records, bean's non-empty fields are updated contents, condiBean' non-empty filds are conditions CAUTION:

                                                                                                                                                                                                                                                                                                                                                                  1.bool will defaultly be updated content nor conditions
                                                                                                                                                                                                                                                                                                                                                                   You should call UseBool if you have bool to use.
                                                                                                                                                                                                                                                                                                                                                                  2.float32 & float64 may be not inexact as conditions
                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                  func (*Engine) UseBool

                                                                                                                                                                                                                                                                                                                                                                  func (engine *Engine) UseBool(columns ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                    UseBool xorm automatically retrieve condition according struct, but if struct has bool field, it will ignore them. So use UseBool to tell system to do not ignore them. If no parameters, it will use all the bool field of struct, or it will use parameters's columns

                                                                                                                                                                                                                                                                                                                                                                    func (*Engine) Where

                                                                                                                                                                                                                                                                                                                                                                    func (engine *Engine) Where(query interface{}, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                      Where method provide a condition query

                                                                                                                                                                                                                                                                                                                                                                      type EngineGroup

                                                                                                                                                                                                                                                                                                                                                                      type EngineGroup struct {
                                                                                                                                                                                                                                                                                                                                                                      	*Engine
                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                        EngineGroup defines an engine group

                                                                                                                                                                                                                                                                                                                                                                        func NewEngineGroup

                                                                                                                                                                                                                                                                                                                                                                        func NewEngineGroup(args1 interface{}, args2 interface{}, policies ...GroupPolicy) (*EngineGroup, error)

                                                                                                                                                                                                                                                                                                                                                                          NewEngineGroup creates a new engine group

                                                                                                                                                                                                                                                                                                                                                                          func (*EngineGroup) Close

                                                                                                                                                                                                                                                                                                                                                                          func (eg *EngineGroup) Close() error

                                                                                                                                                                                                                                                                                                                                                                            Close the engine

                                                                                                                                                                                                                                                                                                                                                                            func (*EngineGroup) Context

                                                                                                                                                                                                                                                                                                                                                                            func (eg *EngineGroup) Context(ctx context.Context) *Session

                                                                                                                                                                                                                                                                                                                                                                              Context returned a group session

                                                                                                                                                                                                                                                                                                                                                                              func (*EngineGroup) Master

                                                                                                                                                                                                                                                                                                                                                                              func (eg *EngineGroup) Master() *Engine

                                                                                                                                                                                                                                                                                                                                                                                Master returns the master engine

                                                                                                                                                                                                                                                                                                                                                                                func (*EngineGroup) NewSession

                                                                                                                                                                                                                                                                                                                                                                                func (eg *EngineGroup) NewSession() *Session

                                                                                                                                                                                                                                                                                                                                                                                  NewSession returned a group session

                                                                                                                                                                                                                                                                                                                                                                                  func (*EngineGroup) Ping

                                                                                                                                                                                                                                                                                                                                                                                  func (eg *EngineGroup) Ping() error

                                                                                                                                                                                                                                                                                                                                                                                    Ping tests if database is alive

                                                                                                                                                                                                                                                                                                                                                                                    func (*EngineGroup) SetColumnMapper

                                                                                                                                                                                                                                                                                                                                                                                    func (eg *EngineGroup) SetColumnMapper(mapper core.IMapper)

                                                                                                                                                                                                                                                                                                                                                                                      SetColumnMapper set the column name mapping rule

                                                                                                                                                                                                                                                                                                                                                                                      func (*EngineGroup) SetConnMaxLifetime

                                                                                                                                                                                                                                                                                                                                                                                      func (eg *EngineGroup) SetConnMaxLifetime(d time.Duration)

                                                                                                                                                                                                                                                                                                                                                                                        SetConnMaxLifetime sets the maximum amount of time a connection may be reused.

                                                                                                                                                                                                                                                                                                                                                                                        func (*EngineGroup) SetDefaultCacher

                                                                                                                                                                                                                                                                                                                                                                                        func (eg *EngineGroup) SetDefaultCacher(cacher core.Cacher)

                                                                                                                                                                                                                                                                                                                                                                                          SetDefaultCacher set the default cacher

                                                                                                                                                                                                                                                                                                                                                                                          func (*EngineGroup) SetLogLevel

                                                                                                                                                                                                                                                                                                                                                                                          func (eg *EngineGroup) SetLogLevel(level core.LogLevel)

                                                                                                                                                                                                                                                                                                                                                                                            SetLogLevel sets the logger level

                                                                                                                                                                                                                                                                                                                                                                                            func (*EngineGroup) SetLogger

                                                                                                                                                                                                                                                                                                                                                                                            func (eg *EngineGroup) SetLogger(logger core.ILogger)

                                                                                                                                                                                                                                                                                                                                                                                              SetLogger set the new logger

                                                                                                                                                                                                                                                                                                                                                                                              func (*EngineGroup) SetMapper

                                                                                                                                                                                                                                                                                                                                                                                              func (eg *EngineGroup) SetMapper(mapper core.IMapper)

                                                                                                                                                                                                                                                                                                                                                                                                SetMapper set the name mapping rules

                                                                                                                                                                                                                                                                                                                                                                                                func (*EngineGroup) SetMaxIdleConns

                                                                                                                                                                                                                                                                                                                                                                                                func (eg *EngineGroup) SetMaxIdleConns(conns int)

                                                                                                                                                                                                                                                                                                                                                                                                  SetMaxIdleConns set the max idle connections on pool, default is 2

                                                                                                                                                                                                                                                                                                                                                                                                  func (*EngineGroup) SetMaxOpenConns

                                                                                                                                                                                                                                                                                                                                                                                                  func (eg *EngineGroup) SetMaxOpenConns(conns int)

                                                                                                                                                                                                                                                                                                                                                                                                    SetMaxOpenConns is only available for go 1.2+

                                                                                                                                                                                                                                                                                                                                                                                                    func (*EngineGroup) SetPolicy

                                                                                                                                                                                                                                                                                                                                                                                                    func (eg *EngineGroup) SetPolicy(policy GroupPolicy) *EngineGroup

                                                                                                                                                                                                                                                                                                                                                                                                      SetPolicy set the group policy

                                                                                                                                                                                                                                                                                                                                                                                                      func (*EngineGroup) SetTableMapper

                                                                                                                                                                                                                                                                                                                                                                                                      func (eg *EngineGroup) SetTableMapper(mapper core.IMapper)

                                                                                                                                                                                                                                                                                                                                                                                                        SetTableMapper set the table name mapping rule

                                                                                                                                                                                                                                                                                                                                                                                                        func (*EngineGroup) ShowExecTime

                                                                                                                                                                                                                                                                                                                                                                                                        func (eg *EngineGroup) ShowExecTime(show ...bool)

                                                                                                                                                                                                                                                                                                                                                                                                          ShowExecTime show SQL statement and execute time or not on logger if log level is great than INFO

                                                                                                                                                                                                                                                                                                                                                                                                          func (*EngineGroup) ShowSQL

                                                                                                                                                                                                                                                                                                                                                                                                          func (eg *EngineGroup) ShowSQL(show ...bool)

                                                                                                                                                                                                                                                                                                                                                                                                            ShowSQL show SQL statement or not on logger if log level is great than INFO

                                                                                                                                                                                                                                                                                                                                                                                                            func (*EngineGroup) Slave

                                                                                                                                                                                                                                                                                                                                                                                                            func (eg *EngineGroup) Slave() *Engine

                                                                                                                                                                                                                                                                                                                                                                                                              Slave returns one of the physical databases which is a slave according the policy

                                                                                                                                                                                                                                                                                                                                                                                                              func (*EngineGroup) Slaves

                                                                                                                                                                                                                                                                                                                                                                                                              func (eg *EngineGroup) Slaves() []*Engine

                                                                                                                                                                                                                                                                                                                                                                                                                Slaves returns all the slaves

                                                                                                                                                                                                                                                                                                                                                                                                                type EngineInterface

                                                                                                                                                                                                                                                                                                                                                                                                                type EngineInterface interface {
                                                                                                                                                                                                                                                                                                                                                                                                                	Interface
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	Before(func(interface{})) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                	Charset(charset string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                	ClearCache(...interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                	Context(context.Context) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                	CreateTables(...interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                	DBMetas() ([]*core.Table, error)
                                                                                                                                                                                                                                                                                                                                                                                                                	Dialect() core.Dialect
                                                                                                                                                                                                                                                                                                                                                                                                                	DropTables(...interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                	DumpAllToFile(fp string, tp ...core.DbType) error
                                                                                                                                                                                                                                                                                                                                                                                                                	GetCacher(string) core.Cacher
                                                                                                                                                                                                                                                                                                                                                                                                                	GetColumnMapper() core.IMapper
                                                                                                                                                                                                                                                                                                                                                                                                                	GetDefaultCacher() core.Cacher
                                                                                                                                                                                                                                                                                                                                                                                                                	GetTableMapper() core.IMapper
                                                                                                                                                                                                                                                                                                                                                                                                                	GetTZDatabase() *time.Location
                                                                                                                                                                                                                                                                                                                                                                                                                	GetTZLocation() *time.Location
                                                                                                                                                                                                                                                                                                                                                                                                                	MapCacher(interface{}, core.Cacher) error
                                                                                                                                                                                                                                                                                                                                                                                                                	NewSession() *Session
                                                                                                                                                                                                                                                                                                                                                                                                                	NoAutoTime() *Session
                                                                                                                                                                                                                                                                                                                                                                                                                	Quote(string) string
                                                                                                                                                                                                                                                                                                                                                                                                                	SetCacher(string, core.Cacher)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetConnMaxLifetime(time.Duration)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetDefaultCacher(core.Cacher)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetLogger(logger core.ILogger)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetLogLevel(core.LogLevel)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetMapper(core.IMapper)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetMaxOpenConns(int)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetMaxIdleConns(int)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetSchema(string)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetTZDatabase(tz *time.Location)
                                                                                                                                                                                                                                                                                                                                                                                                                	SetTZLocation(tz *time.Location)
                                                                                                                                                                                                                                                                                                                                                                                                                	ShowExecTime(...bool)
                                                                                                                                                                                                                                                                                                                                                                                                                	ShowSQL(show ...bool)
                                                                                                                                                                                                                                                                                                                                                                                                                	Sync(...interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                	Sync2(...interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                	StoreEngine(storeEngine string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                	TableInfo(bean interface{}) *Table
                                                                                                                                                                                                                                                                                                                                                                                                                	TableName(interface{}, ...bool) string
                                                                                                                                                                                                                                                                                                                                                                                                                	UnMapType(reflect.Type)
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  EngineInterface defines the interface which Engine, EngineGroup will implementate.

                                                                                                                                                                                                                                                                                                                                                                                                                  type ErrFieldIsNotExist

                                                                                                                                                                                                                                                                                                                                                                                                                  type ErrFieldIsNotExist struct {
                                                                                                                                                                                                                                                                                                                                                                                                                  	FieldName string
                                                                                                                                                                                                                                                                                                                                                                                                                  	TableName string
                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                    ErrFieldIsNotExist columns does not exist

                                                                                                                                                                                                                                                                                                                                                                                                                    func (ErrFieldIsNotExist) Error

                                                                                                                                                                                                                                                                                                                                                                                                                    func (e ErrFieldIsNotExist) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                    type ErrFieldIsNotValid

                                                                                                                                                                                                                                                                                                                                                                                                                    type ErrFieldIsNotValid struct {
                                                                                                                                                                                                                                                                                                                                                                                                                    	FieldName string
                                                                                                                                                                                                                                                                                                                                                                                                                    	TableName string
                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                      ErrFieldIsNotValid is not valid

                                                                                                                                                                                                                                                                                                                                                                                                                      func (ErrFieldIsNotValid) Error

                                                                                                                                                                                                                                                                                                                                                                                                                      func (e ErrFieldIsNotValid) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                      type ErrUnsupportedExprType

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

                                                                                                                                                                                                                                                                                                                                                                                                                      func (ErrUnsupportedExprType) Error

                                                                                                                                                                                                                                                                                                                                                                                                                      func (err ErrUnsupportedExprType) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                      type GroupPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                      type GroupPolicy interface {
                                                                                                                                                                                                                                                                                                                                                                                                                      	Slave(*EngineGroup) *Engine
                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                        GroupPolicy is be used by chosing the current slave from slaves

                                                                                                                                                                                                                                                                                                                                                                                                                        type GroupPolicyHandler

                                                                                                                                                                                                                                                                                                                                                                                                                        type GroupPolicyHandler func(*EngineGroup) *Engine

                                                                                                                                                                                                                                                                                                                                                                                                                          GroupPolicyHandler should be used when a function is a GroupPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                          func LeastConnPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                          func LeastConnPolicy() GroupPolicyHandler

                                                                                                                                                                                                                                                                                                                                                                                                                            LeastConnPolicy implements GroupPolicy, every time will get the least connections slave

                                                                                                                                                                                                                                                                                                                                                                                                                            func RandomPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                            func RandomPolicy() GroupPolicyHandler

                                                                                                                                                                                                                                                                                                                                                                                                                              RandomPolicy implmentes randomly chose the slave of slaves

                                                                                                                                                                                                                                                                                                                                                                                                                              func RoundRobinPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                              func RoundRobinPolicy() GroupPolicyHandler

                                                                                                                                                                                                                                                                                                                                                                                                                              func WeightRandomPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                              func WeightRandomPolicy(weights []int) GroupPolicyHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                WeightRandomPolicy implmentes randomly chose the slave of slaves

                                                                                                                                                                                                                                                                                                                                                                                                                                func WeightRoundRobinPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                func WeightRoundRobinPolicy(weights []int) GroupPolicyHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                func (GroupPolicyHandler) Slave

                                                                                                                                                                                                                                                                                                                                                                                                                                func (h GroupPolicyHandler) Slave(eg *EngineGroup) *Engine

                                                                                                                                                                                                                                                                                                                                                                                                                                  Slave implements the chosen of slaves

                                                                                                                                                                                                                                                                                                                                                                                                                                  type Interface

                                                                                                                                                                                                                                                                                                                                                                                                                                  type Interface interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                  	AllCols() *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Alias(alias string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Asc(colNames ...string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	BufferSize(size int) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Cols(columns ...string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Count(...interface{}) (int64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	CreateIndexes(bean interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                                  	CreateUniques(bean interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Decr(column string, arg ...interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Desc(...string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Delete(interface{}) (int64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Distinct(columns ...string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	DropIndexes(bean interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Exec(sqlOrArgs ...interface{}) (sql.Result, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Exist(bean ...interface{}) (bool, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Find(interface{}, ...interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                                  	FindAndCount(interface{}, ...interface{}) (int64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Get(interface{}) (bool, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	GroupBy(keys string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	ID(interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	In(string, ...interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Incr(column string, arg ...interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Insert(...interface{}) (int64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	InsertOne(interface{}) (int64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	IsTableEmpty(bean interface{}) (bool, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	IsTableExist(beanOrTableName interface{}) (bool, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Iterate(interface{}, IterFunc) error
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Limit(int, ...int) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	MustCols(columns ...string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	NoAutoCondition(...bool) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	NotIn(string, ...interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Omit(columns ...string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	OrderBy(order string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Ping() error
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Query(sqlOrArgs ...interface{}) (resultsSlice []map[string][]byte, err error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Rows(bean interface{}) (*Rows, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	SetExpr(string, interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	SQL(interface{}, ...interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Sum(bean interface{}, colName string) (float64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	SumInt(bean interface{}, colName string) (int64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Sums(bean interface{}, colNames ...string) ([]float64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	SumsInt(bean interface{}, colNames ...string) ([]int64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Table(tableNameOrBean interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Unscoped() *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Update(bean interface{}, condiBeans ...interface{}) (int64, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	UseBool(...string) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  	Where(interface{}, ...interface{}) *Session
                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                    Interface defines the interface which Engine, EngineGroup and Session will implementate.

                                                                                                                                                                                                                                                                                                                                                                                                                                    type IterFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                    type IterFunc func(idx int, bean interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                      IterFunc only use by Iterate

                                                                                                                                                                                                                                                                                                                                                                                                                                      type JSONInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                      type JSONInterface interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Marshal(v interface{}) ([]byte, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                      	Unmarshal(data []byte, v interface{}) error
                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                        JSONInterface represents an interface to handle json data

                                                                                                                                                                                                                                                                                                                                                                                                                                        var (
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// DefaultJSONHandler default json handler
                                                                                                                                                                                                                                                                                                                                                                                                                                        	DefaultJSONHandler JSONInterface = StdJSON{}
                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                        type LRUCacher

                                                                                                                                                                                                                                                                                                                                                                                                                                        type LRUCacher struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                        	MaxElementSize int
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Expired        time.Duration
                                                                                                                                                                                                                                                                                                                                                                                                                                        	GcInterval     time.Duration
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                          LRUCacher implments cache object facilities

                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewLRUCacher

                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewLRUCacher(store core.CacheStore, maxElementSize int) *LRUCacher

                                                                                                                                                                                                                                                                                                                                                                                                                                            NewLRUCacher creates a cacher

                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewLRUCacher2

                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewLRUCacher2(store core.CacheStore, expired time.Duration, maxElementSize int) *LRUCacher

                                                                                                                                                                                                                                                                                                                                                                                                                                              NewLRUCacher2 creates a cache include different params

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*LRUCacher) ClearBeans

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *LRUCacher) ClearBeans(tableName string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                ClearBeans clears all beans in some table

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*LRUCacher) ClearIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *LRUCacher) ClearIds(tableName string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                  ClearIds clears all sql-ids mapping on table tableName from cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*LRUCacher) DelBean

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *LRUCacher) DelBean(tableName string, id string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                    DelBean deletes beans in some table

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*LRUCacher) DelIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *LRUCacher) DelIds(tableName, sql string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                      DelIds deletes ids

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*LRUCacher) GC

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *LRUCacher) GC()

                                                                                                                                                                                                                                                                                                                                                                                                                                                        GC check ids lit and sql list to remove all element expired

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*LRUCacher) GetBean

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *LRUCacher) GetBean(tableName string, id string) interface{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetBean returns bean according tableName and id from cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*LRUCacher) GetIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *LRUCacher) GetIds(tableName, sql string) interface{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetIds returns all bean's ids according to sql and parameter from cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*LRUCacher) PutBean

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *LRUCacher) PutBean(tableName string, id string, obj interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                              PutBean puts beans into table

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*LRUCacher) PutIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *LRUCacher) PutIds(tableName, sql string, ids interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                PutIds pus ids into table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*LRUCacher) RunGC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *LRUCacher) RunGC()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RunGC run once every m.GcInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MemoryStore

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MemoryStore represents in-memory store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewMemoryStore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewMemoryStore() *MemoryStore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewMemoryStore creates a new store in memory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MemoryStore) Del

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *MemoryStore) Del(key string) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Del deletes object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MemoryStore) Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *MemoryStore) Get(key string) (interface{}, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Get gets object from store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MemoryStore) Put

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *MemoryStore) Put(key string, value interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Put puts object into store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Rows

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Rows rows wrapper a rows to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Rows) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (rows *Rows) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Close session if session.IsAutoClose is true, and claimed any opened resources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Rows) Err

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (rows *Rows) Err() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Err returns the error, if any, that was encountered during iteration. Err may be called after an explicit or implicit Close.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Rows) Next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (rows *Rows) Next() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Next move cursor to next record, return false if end has reached

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Rows) Scan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (rows *Rows) Scan(bean interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Scan row record to bean properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Session

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Session keep a pointer to sql.DB and provides all execution of all kind of database operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) After

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) After(closures func(interface{})) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          After Apply after Processor, affected bean is passed to closure arg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Alias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Alias(alias string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Alias set the table alias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) AllCols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) AllCols() *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AllCols ask all columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) And

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) And(query interface{}, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                And provides custom query condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) Asc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) Asc(colNames ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Asc provide asc order by query condition, the input parameters are columns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) Before

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) Before(closures func(interface{})) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before Apply before Processor, affected bean is passed to closure arg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) Begin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) Begin() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Begin a transaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) BufferSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) BufferSize(size int) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BufferSize sets the buffersize for iterate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) Cascade

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) Cascade(trueOrFalse ...bool) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Cascade indicates if loading sub Struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Charset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Charset(charset string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Charset is only avialble mysql dialect currently

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) Clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) Clone() *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Clone copy all the session's content and return a new session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) Close()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Close release the connection from pool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) Cols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) Cols(columns ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Cols provides some columns to special

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) Commit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) Commit() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Commit When using transaction, Commit will commit all operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) Conds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) Conds() builder.Cond

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Conds returns session query conditions except auto bean conditions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) Context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) Context(ctx context.Context) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Context sets the context on this session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) ContextCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) ContextCache(context ContextCache) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ContextCache enable context cache or not

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Count(bean ...interface{}) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Count counts the records. bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) CreateIndexes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) CreateIndexes(bean interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CreateIndexes create indexes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) CreateTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) CreateTable(bean interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CreateTable create a table according a bean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) CreateUniques

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) CreateUniques(bean interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CreateUniques create uniques

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) DB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) DB() *core.DB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DB db return the wrapper of sql.DB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) Decr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) Decr(column string, arg ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Decr provides a query string like "count = count - 1"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) Delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) Delete(bean interface{}) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Delete records, bean's non-empty fields are conditions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) Desc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) Desc(colNames ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Desc provide desc order by query condition, the input parameters are columns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Distinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Distinct(columns ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Distinct use for distinct columns. Caution: when you are using cache, distinct will not be cached because cache system need id, but distinct will not provide id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) DropIndexes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) DropIndexes(bean interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DropIndexes drop indexes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) DropTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) DropTable(beanOrTableName interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DropTable drop table will drop table if exist, if drop failed, it will return error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) Exec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) Exec(sqlOrArgs ...interface{}) (sql.Result, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Exec raw sql

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) Exist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) Exist(bean ...interface{}) (bool, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exist returns true if the record exist otherwise return false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) Find

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Find retrieve records from table, condiBeans's non-empty fields are conditions. beans could be []Struct, []*Struct, map[int64]Struct map[int64]*Struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) FindAndCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) FindAndCount(rowsSlicePtr interface{}, condiBean ...interface{}) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        FindAndCount find the results and also return the counts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) ForUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) ForUpdate() *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ForUpdate Set Read/Write locking for UPDATE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Get(bean interface{}) (bool, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Get retrieve one record from database, bean's non-empty fields will be as conditions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) GroupBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) GroupBy(keys string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GroupBy Generate Group By statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) Having

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) Having(conditions string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Having Generate Having statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) ID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) ID(id interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ID provides converting id as a query condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) Id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) Id(id interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Id provides converting id as a query condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated: use ID instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) In

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) In(column string, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      In provides a query string like "id in (1, 2, 3)"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) Incr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) Incr(column string, arg ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Incr provides a query string like "count = count + 1"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) Init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) Init()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Init reset the session as the init status.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Insert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Insert(beans ...interface{}) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Insert insert one or more beans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) InsertMulti

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InsertMulti insert multiple records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) InsertOne

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) InsertOne(bean interface{}) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                InsertOne insert only one struct into database as a record. The in parameter bean must a struct or a point to struct. The return parameter is inserted and error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) IsClosed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) IsClosed() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IsClosed returns if session is closed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) IsTableEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) IsTableEmpty(bean interface{}) (bool, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IsTableEmpty if table have any records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) IsTableExist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) IsTableExist(beanOrTableName interface{}) (bool, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      IsTableExist if a table is exist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) Iterate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) Iterate(bean interface{}, fun IterFunc) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Iterate record by record handle records from table, condiBeans's non-empty fields are conditions. beans could be []Struct, []*Struct, map[int64]Struct map[int64]*Struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) Join

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Join join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) LastSQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) LastSQL() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LastSQL returns last query information

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) Limit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) Limit(limit int, start ...int) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Limit provide limit and offset query condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) MustCols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) MustCols(columns ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MustCols specify some columns must use even if they are empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) NoAutoCondition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) NoAutoCondition(no ...bool) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NoAutoCondition disable generate SQL condition from beans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) NoAutoTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) NoAutoTime() *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NoAutoTime means do not automatically give created field and updated field the current time on the current session temporarily

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) NoCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) NoCache() *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NoCache ask this session do not retrieve data from cache system and get data from database directly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) NoCascade

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) NoCascade() *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NoCascade indicate that no cascade load child object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) NotIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) NotIn(column string, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NotIn provides a query string like "id in (1, 2, 3)"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Nullable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Nullable(columns ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nullable Set null when column is zero-value and nullable for update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) Omit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) Omit(columns ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Omit Only not use the parameters as select or update columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) Or

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) Or(query interface{}, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Or provides custom query condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) OrderBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) OrderBy(order string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OrderBy provide order by query condition, the input parameter is the content after order by on a sql statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) Ping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) Ping() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ping test if database is ok

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) PingContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) PingContext(ctx context.Context) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PingContext test if database is ok

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) Prepare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) Prepare() *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Prepare set a flag to session that should be prepare statement before execute query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) Query(sqlOrArgs ...interface{}) ([]map[string][]byte, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Query runs a raw sql and return records as []map[string][]byte

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) QueryInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            QueryInterface runs a raw sql and return records as []map[string]interface{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) QuerySliceString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) QuerySliceString(sqlOrArgs ...interface{}) ([][]string, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              QuerySliceString runs a raw sql and return records as [][]string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) QueryString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                QueryString runs a raw sql and return records as []map[string]string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) Rollback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) Rollback() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Rollback When using transaction, you can rollback if any error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) Rows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) Rows(bean interface{}) (*Rows, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) SQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) SQL(query interface{}, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SQL provides raw sql input parameter. When you have a complex SQL statement and cannot use Where, Id, In and etc. Methods to describe, you can use SQL.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) Select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) Select(str string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Select provides some columns to special

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) SetExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) SetExpr(column string, expression interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetExpr provides a query string like "column = {expression}"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Sql

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Sql(query string, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sql provides raw sql input parameter. When you have a complex SQL statement and cannot use Where, Id, In and etc. Methods to describe, you can use SQL.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated: use SQL instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) StoreEngine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) StoreEngine(storeEngine string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              StoreEngine is only avialble mysql dialect currently

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) Sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) Sum(bean interface{}, columnName string) (res float64, err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Sum call sum some column. bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) SumInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) SumInt(bean interface{}, columnName string) (res int64, err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SumInt call sum some column. bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Session) Sums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sums call sum some columns. bean's non-empty fields are conditions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Session) SumsInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) SumsInt(bean interface{}, columnNames ...string) ([]int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SumsInt sum specify columns and return as []int64 instead of []float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Session) Sync2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) Sync2(beans ...interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sync2 synchronize structs to database tables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) Table(tableNameOrBean interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Table can input a string or pointer to struct for special a table to operate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Session) Unscoped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (session *Session) Unscoped() *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Unscoped always disable struct tag "deleted"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) Update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Update records, bean's non-empty fields are updated contents, condiBean' non-empty filds are conditions CAUTION:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1.bool will defaultly be updated content nor conditions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               You should call UseBool if you have bool to use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              2.float32 & float64 may be not inexact as conditions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Session) UseBool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (session *Session) UseBool(columns ...string) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UseBool automatically retrieve condition according struct, but if struct has bool field, it will ignore them. So use UseBool to tell system to do not ignore them. If no parameters, it will use all the bool field of struct, or it will use parameters's columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Session) Where

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (session *Session) Where(query interface{}, args ...interface{}) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Where provides custom query condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SimpleLogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SimpleLogger struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DEBUG *log.Logger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ERR   *log.Logger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	INFO  *log.Logger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	WARN  *log.Logger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SimpleLogger is the default implment of core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSimpleLogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSimpleLogger(out io.Writer) *SimpleLogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewSimpleLogger use a special io.Writer as logger output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSimpleLogger2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSimpleLogger2(out io.Writer, prefix string, flag int) *SimpleLogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewSimpleLogger2 let you customrize your logger prefix and flag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewSimpleLogger3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewSimpleLogger3(out io.Writer, prefix string, flag int, l core.LogLevel) *SimpleLogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewSimpleLogger3 let you customrize your logger prefix and flag and logLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SimpleLogger) Debug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *SimpleLogger) Debug(v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Debug implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SimpleLogger) Debugf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *SimpleLogger) Debugf(format string, v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Debugf implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SimpleLogger) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *SimpleLogger) Error(v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Error implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SimpleLogger) Errorf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *SimpleLogger) Errorf(format string, v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Errorf implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SimpleLogger) Info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *SimpleLogger) Info(v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Info implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*SimpleLogger) Infof

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *SimpleLogger) Infof(format string, v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Infof implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SimpleLogger) IsShowSQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *SimpleLogger) IsShowSQL() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IsShowSQL implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SimpleLogger) Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *SimpleLogger) Level() core.LogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Level implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SimpleLogger) SetLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *SimpleLogger) SetLevel(l core.LogLevel)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetLevel implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SimpleLogger) ShowSQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *SimpleLogger) ShowSQL(show ...bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ShowSQL implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SimpleLogger) Warn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *SimpleLogger) Warn(v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Warn implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SimpleLogger) Warnf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *SimpleLogger) Warnf(format string, v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Warnf implement core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Statement struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RefTable *core.Table
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Engine   *Engine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Start    int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LimitN   int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	OrderStr string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	JoinStr  string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	GroupByStr string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HavingStr  string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ColumnStr  string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	OmitStr      string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AltTableName string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RawSQL      string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RawParams   []interface{}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	UseCascade  bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	UseAutoJoin bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	StoreEngine string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Charset     string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	UseCache    bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	UseAutoTime bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	IsDistinct  bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	IsForUpdate bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TableAlias  string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Statement save all the sql info for executing SQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Statement) Alias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (statement *Statement) Alias(alias string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Alias set the table alias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Statement) AllCols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (statement *Statement) AllCols() *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        AllCols update use only: update all columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Statement) And

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (statement *Statement) And(query interface{}, args ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          And add Where & and statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Statement) Asc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (statement *Statement) Asc(colNames ...string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Asc provide asc order by query condition, the input parameters are columns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Statement) Cols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (statement *Statement) Cols(columns ...string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Cols generate "col1, col2" statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Statement) Decr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (statement *Statement) Decr(column string, arg ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Decr Generate "Update ... Set column = column - arg" statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Statement) Desc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (statement *Statement) Desc(colNames ...string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Desc generate `ORDER BY xx DESC`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Statement) Distinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (statement *Statement) Distinct(columns ...string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Distinct generates "DISTINCT col1, col2 " statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Statement) ForUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (statement *Statement) ForUpdate() *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ForUpdate generates "SELECT ... FOR UPDATE" statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Statement) GroupBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (statement *Statement) GroupBy(keys string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GroupBy generate "Group By keys" statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Statement) Having

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (statement *Statement) Having(conditions string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Having generate "Having conditions" statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Statement) ID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (statement *Statement) ID(id interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ID generate "where id = ? " statement or for composite key "where key1 = ? and key2 = ?"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Statement) In

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (statement *Statement) In(column string, args ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              In generate "Where column IN (?) " statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Statement) Incr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (statement *Statement) Incr(column string, arg ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Incr Generate "Update ... Set column = column + arg" statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Statement) Init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (statement *Statement) Init()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Init reset all the statement's fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Statement) Join

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (statement *Statement) Join(joinOP string, tablename interface{}, condition string, args ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Join The joinOP should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Statement) Limit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (statement *Statement) Limit(limit int, start ...int) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Limit generate LIMIT start, limit statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Statement) MustCols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (statement *Statement) MustCols(columns ...string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MustCols update use only: must update columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Statement) NoAutoCondition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (statement *Statement) NoAutoCondition(no ...bool) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NoAutoCondition if you do not want convert bean's field as query condition, then use this function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Statement) NotIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (statement *Statement) NotIn(column string, args ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NotIn generate "Where column NOT IN (?) " statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Statement) Nullable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (statement *Statement) Nullable(columns ...string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nullable Update use only: update columns to null when value is nullable and zero-value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Statement) Omit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (statement *Statement) Omit(columns ...string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Omit do not use the columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Statement) Or

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (statement *Statement) Or(query interface{}, args ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Or add Where & Or statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Statement) OrderBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (statement *Statement) OrderBy(order string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OrderBy generate "Order By order" statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Statement) SQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (statement *Statement) SQL(query interface{}, args ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SQL adds raw sql statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Statement) Select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (statement *Statement) Select(str string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Select replace select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Statement) SetExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (statement *Statement) SetExpr(column string, expression interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetExpr Generate "Update ... Set column = {expression}" statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Statement) Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (statement *Statement) Table(tableNameOrBean interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Table tempororily set table name, the parameter could be a string or a pointer of struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Statement) TableName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (statement *Statement) TableName() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TableName return current tableName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Statement) Top

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (statement *Statement) Top(limit int) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Top generate LIMIT limit statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Statement) Unscoped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (statement *Statement) Unscoped() *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Unscoped always disable struct tag "deleted"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Statement) UseBool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (statement *Statement) UseBool(columns ...string) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UseBool indicates that use bool fields as update contents and query contiditions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Statement) Where

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (statement *Statement) Where(query interface{}, args ...interface{}) *Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Where add Where statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type StdJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type StdJSON struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        StdJSON implements JSONInterface via encoding/json

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (StdJSON) Marshal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (StdJSON) Marshal(v interface{}) ([]byte, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Marshal implements JSONInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (StdJSON) Unmarshal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (StdJSON) Unmarshal(data []byte, v interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Unmarshal implements JSONInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SyslogLogger

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SyslogLogger will be depricated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewSyslogLogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewSyslogLogger(w *syslog.Writer) *SyslogLogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewSyslogLogger implements core.ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SyslogLogger) Debug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *SyslogLogger) Debug(v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Debug log content as Debug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SyslogLogger) Debugf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *SyslogLogger) Debugf(format string, v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Debugf log content as Debug and format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*SyslogLogger) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *SyslogLogger) Error(v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Error log content as Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SyslogLogger) Errorf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *SyslogLogger) Errorf(format string, v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Errorf log content as Errorf and format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SyslogLogger) Info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *SyslogLogger) Info(v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Info log content as Info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SyslogLogger) Infof

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *SyslogLogger) Infof(format string, v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Infof log content as Infof and format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SyslogLogger) IsShowSQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *SyslogLogger) IsShowSQL() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsShowSQL if logging SQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SyslogLogger) Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *SyslogLogger) Level() core.LogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Level shows log level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SyslogLogger) SetLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *SyslogLogger) SetLevel(l core.LogLevel)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetLevel always return error, as current log/syslog package doesn't allow to set priority level after syslog.Writer created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SyslogLogger) ShowSQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *SyslogLogger) ShowSQL(show ...bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ShowSQL set if logging SQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*SyslogLogger) Warn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *SyslogLogger) Warn(v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Warn log content as Warn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SyslogLogger) Warnf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *SyslogLogger) Warnf(format string, v ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Warnf log content as Warnf and format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Table struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	*core.Table
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Name string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Table table struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Table) IsValid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *Table) IsValid() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IsValid if table is valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TableName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TableName interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TableName() string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TableName table name interface to define customerize table name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Path Synopsis