README

xorm

中文

Xorm is a simple and powerful ORM for Go.

Build Status

Notice

v1.0.0 has some break changes from v0.8.2.

  • Removed some non gonic function name Id, Sql, please use ID, SQL instead.
  • Removed the dependent from xorm.io/core and moved the codes to xorm.io/xorm/core, xorm.io/xorm/names, xorm.io/xorm/schemas and others.
  • Renamed some interface names. i.e. core.IMapper -> names.Mapper, core.ILogger -> log.Logger.

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 via xorm.io/reverse
  • Simple cascade loading support
  • Optimistic Locking support
  • SQL Builder support via xorm.io/builder
  • Automatical Read/Write seperatelly
  • Postgres schema support
  • Context Cache support
  • Support log/SQLLog context

Drivers Support

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

Installation

go get xorm.io/xorm

Documents

Quick Start

  • Create Engine

Firstly, we should new an engine for a database.

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 transaction 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
  • Transaction should be 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 you can also go to Xorm on discourse 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

You can find all the changelog here

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.11+ and then:

go get xorm.io/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(schemas.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

This section is empty.

Variables

View Source
var (
	// ErrPtrSliceType represents a type error
	ErrPtrSliceType = errors.New("A point to a slice is needed")
	// 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")
	// ErrConditionType condition type unsupported
	ErrConditionType = errors.New("Unsupported condition type")
)
View Source
var (
	// 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")
)
View Source
var ErrNoElementsOnSlice = errors.New("No element on slice when insert")

    ErrNoElementsOnSlice represents an error there is no element when insert

    Functions

    This section is empty.

    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 Engine

                          type Engine struct {
                          	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 NewEngineWithDialectAndDB

                              func NewEngineWithDialectAndDB(driverName, dataSourceName string, dialect dialects.Dialect, db *core.DB) (*Engine, error)

                                NewEngineWithDialectAndDB new a db manager according to the parameter. If you do not want to use your own dialect or db, please use NewEngine. For creating dialect, you can call dialects.OpenDialect. And, for creating db, you can call core.Open or core.FromDB.

                                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 dialects.

                                  func (*Engine) AddHook

                                  func (engine *Engine) AddHook(hook contexts.Hook)

                                  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) 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) Context

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

                                                              ContextHook 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() ([]*schemas.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() dialects.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 ...schemas.DBType) error

                                                                                              DumpAll dump database all table structs and data to w

                                                                                              func (*Engine) DumpAllToFile

                                                                                              func (engine *Engine) DumpAllToFile(fp string, tp ...schemas.DBType) error

                                                                                                DumpAllToFile dump database all table structs and data to a file

                                                                                                func (*Engine) DumpTables

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

                                                                                                  DumpTables dump specify tables to io.Writer

                                                                                                  func (*Engine) DumpTablesToFile

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

                                                                                                    DumpTablesToFile dump specified tables to SQL file.

                                                                                                    func (*Engine) EnableSessionID

                                                                                                    func (engine *Engine) EnableSessionID(enable bool)

                                                                                                      EnableSessionID if enable session id

                                                                                                      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) caches.Cacher

                                                                                                                  GetCacher returns the cachher of the special table

                                                                                                                  func (*Engine) GetColumnMapper

                                                                                                                  func (engine *Engine) GetColumnMapper() names.Mapper

                                                                                                                    GetColumnMapper returns the column name mapper

                                                                                                                    func (*Engine) GetDefaultCacher

                                                                                                                    func (engine *Engine) GetDefaultCacher() caches.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() names.Mapper

                                                                                                                            GetTableMapper returns the table name mapper

                                                                                                                            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) 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() log.ContextLogger

                                                                                                                                                          Logger return the logger interface

                                                                                                                                                          func (*Engine) MapCacher

                                                                                                                                                          func (engine *Engine) MapCacher(bean interface{}, cacher caches.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 *schemas.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 caches.Cacher)

                                                                                                                                                                                                            SetCacher sets cacher for the table

                                                                                                                                                                                                            func (*Engine) SetColumnMapper

                                                                                                                                                                                                            func (engine *Engine) SetColumnMapper(mapper names.Mapper)

                                                                                                                                                                                                              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 caches.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 log.LogLevel)

                                                                                                                                                                                                                          SetLogLevel sets the logger level

                                                                                                                                                                                                                          func (*Engine) SetLogger

                                                                                                                                                                                                                          func (engine *Engine) SetLogger(logger interface{})

                                                                                                                                                                                                                            SetLogger set the new logger

                                                                                                                                                                                                                            func (*Engine) SetMapper

                                                                                                                                                                                                                            func (engine *Engine) SetMapper(mapper names.Mapper)

                                                                                                                                                                                                                              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) SetQuotePolicy

                                                                                                                                                                                                                                  func (engine *Engine) SetQuotePolicy(quotePolicy dialects.QuotePolicy)

                                                                                                                                                                                                                                    SetQuotePolicy sets the special quote policy

                                                                                                                                                                                                                                    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 names.Mapper)

                                                                                                                                                                                                                                            SetTableMapper set the table name mapping rule

                                                                                                                                                                                                                                            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) 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) 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{}) (*schemas.Table, error)

                                                                                                                                                                                                                                                                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 remove table from tables cache

                                                                                                                                                                                                                                                                      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) AddHook

                                                                                                                                                                                                                                                                                  func (eg *EngineGroup) AddHook(hook contexts.Hook)

                                                                                                                                                                                                                                                                                  func (*EngineGroup) Close

                                                                                                                                                                                                                                                                                  func (eg *EngineGroup) Close() error

                                                                                                                                                                                                                                                                                    Close the engine

                                                                                                                                                                                                                                                                                    func (*EngineGroup) Context

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

                                                                                                                                                                                                                                                                                      ContextHook 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 names.Mapper)

                                                                                                                                                                                                                                                                                              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 caches.Cacher)

                                                                                                                                                                                                                                                                                                  SetDefaultCacher set the default cacher

                                                                                                                                                                                                                                                                                                  func (*EngineGroup) SetLogLevel

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

                                                                                                                                                                                                                                                                                                    SetLogLevel sets the logger level

                                                                                                                                                                                                                                                                                                    func (*EngineGroup) SetLogger

                                                                                                                                                                                                                                                                                                    func (eg *EngineGroup) SetLogger(logger interface{})

                                                                                                                                                                                                                                                                                                      SetLogger set the new logger

                                                                                                                                                                                                                                                                                                      func (*EngineGroup) SetMapper

                                                                                                                                                                                                                                                                                                      func (eg *EngineGroup) SetMapper(mapper names.Mapper)

                                                                                                                                                                                                                                                                                                        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) SetQuotePolicy

                                                                                                                                                                                                                                                                                                              func (eg *EngineGroup) SetQuotePolicy(quotePolicy dialects.QuotePolicy)

                                                                                                                                                                                                                                                                                                                SetQuotePolicy sets the special quote policy

                                                                                                                                                                                                                                                                                                                func (*EngineGroup) SetTableMapper

                                                                                                                                                                                                                                                                                                                func (eg *EngineGroup) SetTableMapper(mapper names.Mapper)

                                                                                                                                                                                                                                                                                                                  SetTableMapper set the table name mapping rule

                                                                                                                                                                                                                                                                                                                  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() ([]*schemas.Table, error)
                                                                                                                                                                                                                                                                                                                        	Dialect() dialects.Dialect
                                                                                                                                                                                                                                                                                                                        	DriverName() string
                                                                                                                                                                                                                                                                                                                        	DropTables(...interface{}) error
                                                                                                                                                                                                                                                                                                                        	DumpAllToFile(fp string, tp ...schemas.DBType) error
                                                                                                                                                                                                                                                                                                                        	GetCacher(string) caches.Cacher
                                                                                                                                                                                                                                                                                                                        	GetColumnMapper() names.Mapper
                                                                                                                                                                                                                                                                                                                        	GetDefaultCacher() caches.Cacher
                                                                                                                                                                                                                                                                                                                        	GetTableMapper() names.Mapper
                                                                                                                                                                                                                                                                                                                        	GetTZDatabase() *time.Location
                                                                                                                                                                                                                                                                                                                        	GetTZLocation() *time.Location
                                                                                                                                                                                                                                                                                                                        	ImportFile(fp string) ([]sql.Result, error)
                                                                                                                                                                                                                                                                                                                        	MapCacher(interface{}, caches.Cacher) error
                                                                                                                                                                                                                                                                                                                        	NewSession() *Session
                                                                                                                                                                                                                                                                                                                        	NoAutoTime() *Session
                                                                                                                                                                                                                                                                                                                        	Quote(string) string
                                                                                                                                                                                                                                                                                                                        	SetCacher(string, caches.Cacher)
                                                                                                                                                                                                                                                                                                                        	SetConnMaxLifetime(time.Duration)
                                                                                                                                                                                                                                                                                                                        	SetColumnMapper(names.Mapper)
                                                                                                                                                                                                                                                                                                                        	SetDefaultCacher(caches.Cacher)
                                                                                                                                                                                                                                                                                                                        	SetLogger(logger interface{})
                                                                                                                                                                                                                                                                                                                        	SetLogLevel(log.LogLevel)
                                                                                                                                                                                                                                                                                                                        	SetMapper(names.Mapper)
                                                                                                                                                                                                                                                                                                                        	SetMaxOpenConns(int)
                                                                                                                                                                                                                                                                                                                        	SetMaxIdleConns(int)
                                                                                                                                                                                                                                                                                                                        	SetQuotePolicy(dialects.QuotePolicy)
                                                                                                                                                                                                                                                                                                                        	SetSchema(string)
                                                                                                                                                                                                                                                                                                                        	SetTableMapper(names.Mapper)
                                                                                                                                                                                                                                                                                                                        	SetTZDatabase(tz *time.Location)
                                                                                                                                                                                                                                                                                                                        	SetTZLocation(tz *time.Location)
                                                                                                                                                                                                                                                                                                                        	AddHook(hook contexts.Hook)
                                                                                                                                                                                                                                                                                                                        	ShowSQL(show ...bool)
                                                                                                                                                                                                                                                                                                                        	Sync(...interface{}) error
                                                                                                                                                                                                                                                                                                                        	Sync2(...interface{}) error
                                                                                                                                                                                                                                                                                                                        	StoreEngine(storeEngine string) *Session
                                                                                                                                                                                                                                                                                                                        	TableInfo(bean interface{}) (*schemas.Table, error)
                                                                                                                                                                                                                                                                                                                        	TableName(interface{}, ...bool) string
                                                                                                                                                                                                                                                                                                                        	UnMapType(reflect.Type)
                                                                                                                                                                                                                                                                                                                        	EnableSessionID(bool)
                                                                                                                                                                                                                                                                                                                        }

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

                                                                                                                                                                                                                                                                                                                                        RoundRobinPolicy returns a group policy handler

                                                                                                                                                                                                                                                                                                                                        func WeightRandomPolicy

                                                                                                                                                                                                                                                                                                                                        func WeightRandomPolicy(weights []int) GroupPolicyHandler

                                                                                                                                                                                                                                                                                                                                          WeightRandomPolicy implmentes randomly chose the slave of slaves

                                                                                                                                                                                                                                                                                                                                          func WeightRoundRobinPolicy

                                                                                                                                                                                                                                                                                                                                          func WeightRoundRobinPolicy(weights []int) GroupPolicyHandler

                                                                                                                                                                                                                                                                                                                                            WeightRoundRobinPolicy returns a group policy handler

                                                                                                                                                                                                                                                                                                                                            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
                                                                                                                                                                                                                                                                                                                                              	Select(string) *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 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) Close

                                                                                                                                                                                                                                                                                                                                                                                  func (session *Session) Close() error

                                                                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                                                                            ContextHook sets the context on this session

                                                                                                                                                                                                                                                                                                                                                                                            func (*Session) ContextCache

                                                                                                                                                                                                                                                                                                                                                                                            func (session *Session) ContextCache(context contexts.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) Engine

                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) Engine() *Engine

                                                                                                                                                                                                                                                                                                                                                                                                                    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) Import

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (session *Session) Import(r io.Reader) ([]sql.Result, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                        Import SQL DDL from io.Reader

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Session) ImportFile

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (session *Session) ImportFile(ddlPath string) ([]sql.Result, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                          ImportFile SQL DDL file

                                                                                                                                                                                                                                                                                                                                                                                                                                          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) 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) MustLogSQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (session *Session) MustLogSQL(logs ...bool) *Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MustLogSQL means record SQL or not and don't follow engine's setting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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) 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 Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Table struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	*schemas.Table
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Name string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Table table struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Table) IsValid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *Table) IsValid() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          IsValid if table is valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          internal