Documentation

Index

Constants

View Source
const (
	// DriverMysql is a const value of mysql driver.
	DriverMysql = "mysql"
	// DriverSqlite is a const value of sqlite driver.
	DriverSqlite = "sqlite"
	// DriverPostgresql is a const value of postgresql driver.
	DriverPostgresql = "postgresql"
	// DriverMssql is a const value of mssql driver.
	DriverMssql = "mssql"
)
View Source
const (
	INSERT = 0
	DELETE = 1
	UPDATE = 2
	QUERY  = 3
)

Variables

View Source
var (
	// StringTypeList is a DatabaseType list of string.
	StringTypeList = []DatabaseType{Date, Time, Year, Datetime, Timestamptz, Timestamp, Timetz,
		Varchar, Char, Mediumtext, Longtext, Tinytext,
		Text, JSON, Blob, Tinyblob, Mediumblob, Longblob,
		Interval, Point, Bpchar,
		Line, Lseg, Box, Path, Polygon, Circle, Cidr, Inet, Macaddr, Character, Varyingcharacter,
		Nchar, Nativecharacter, Nvarchar, Clob, Binary, Varbinary, Enum, Set, Geometry, Multilinestring,
		Multipolygon, Linestring, Multipoint, Geometrycollection, Name, UUID, Timestamptz,
		Name, UUID, Inet}

	// BoolTypeList is a DatabaseType list of bool.
	BoolTypeList = []DatabaseType{Bool, Boolean}

	// IntTypeList is a DatabaseType list of integer.
	IntTypeList = []DatabaseType{Int4, Int2, Int8,
		Int,
		Tinyint,
		Mediumint,
		Smallint,
		Smallserial, Serial, Bigserial,
		Integer,
		Bigint}

	// FloatTypeList is a DatabaseType list of float.
	FloatTypeList = []DatabaseType{Float, Float4, Float8, Double, Real, Doubleprecision}

	// UintTypeList is a DatabaseType list of uint.
	UintTypeList = []DatabaseType{Decimal, Bit, Money, Numeric}
)
View Source
var SQLPool = sync.Pool{
	New: func() interface{} {
		return &SQL{
			SQLComponent: dialect.SQLComponent{
				Fields:     make([]string, 0),
				TableName:  "",
				Args:       make([]interface{}, 0),
				Wheres:     make([]dialect.Where, 0),
				Leftjoins:  make([]dialect.Join, 0),
				UpdateRaws: make([]dialect.RawUpdate, 0),
				WhereRaws:  "",
				Order:      "",
				Group:      "",
				Limit:      "",
			},
			diver:   nil,
			dialect: nil,
		}
	},
}

    SQLPool is a object pool of SQL.

    Functions

    func CheckError

    func CheckError(err error, t int) bool

    func CommonBeginTxWithLevel

    func CommonBeginTxWithLevel(db *sql.DB, level sql.IsolationLevel) *sql.Tx

      CommonBeginTxWithLevel starts a transaction with given transaction isolation level and db connection.

      func CommonExec

      func CommonExec(db *sql.DB, query string, args ...interface{}) (sql.Result, error)

        CommonExec is a common method of exec.

        func CommonExecWithTx

        func CommonExecWithTx(tx *sql.Tx, query string, args ...interface{}) (sql.Result, error)

          CommonExecWithTx is a common method of exec.

          func CommonQuery

          func CommonQuery(db *sql.DB, query string, args ...interface{}) ([]map[string]interface{}, error)

            CommonQuery is a common method of query.

            func CommonQueryWithTx

            func CommonQueryWithTx(tx *sql.Tx, query string, args ...interface{}) ([]map[string]interface{}, error)

              CommonQueryWithTx is a common method of query.

              func Contains

              func Contains(v DatabaseType, a []DatabaseType) bool

                Contains check the given DatabaseType is in the list or not.

                func GetAggregationExpression

                func GetAggregationExpression(driver, field, headField, delimiter string) string

                func RecycleSQL

                func RecycleSQL(sql *SQL)

                  RecycleSQL clear the SQL and put into the pool.

                  func SetColVarType

                  func SetColVarType(colVar *[]interface{}, i int, typeName string)

                    SetColVarType set the column type.

                    func SetResultValue

                    func SetResultValue(result *map[string]interface{}, index string, colVar interface{}, typeName string)

                      SetResultValue set the result value.

                      Types

                      type Base

                      type Base struct {
                      	DbList  map[string]*sql.DB
                      	Once    sync.Once
                      	Configs config.DatabaseList
                      }

                        Base is a common Connection.

                        func (*Base) Close

                        func (db *Base) Close() []error

                          Close implements the method Connection.Close.

                          func (*Base) CreateDB

                          func (db *Base) CreateDB(name string, beans ...interface{}) error

                          func (*Base) GetConfig

                          func (db *Base) GetConfig(name string) config.Database

                          func (*Base) GetDB

                          func (db *Base) GetDB(key string) *sql.DB

                            GetDB implements the method Connection.GetDB.

                            type Connection

                            type Connection interface {
                            	// Query is the query method of sql.
                            	Query(query string, args ...interface{}) ([]map[string]interface{}, error)
                            
                            	// Exec is the exec method of sql.
                            	Exec(query string, args ...interface{}) (sql.Result, error)
                            
                            	// QueryWithConnection is the query method with given connection of sql.
                            	QueryWithConnection(conn, query string, args ...interface{}) ([]map[string]interface{}, error)
                            	QueryWithTx(tx *sql.Tx, query string, args ...interface{}) ([]map[string]interface{}, error)
                            	QueryWith(tx *sql.Tx, conn, query string, args ...interface{}) ([]map[string]interface{}, error)
                            
                            	// ExecWithConnection is the exec method with given connection of sql.
                            	ExecWithConnection(conn, query string, args ...interface{}) (sql.Result, error)
                            	ExecWithTx(tx *sql.Tx, query string, args ...interface{}) (sql.Result, error)
                            	ExecWith(tx *sql.Tx, conn, query string, args ...interface{}) (sql.Result, error)
                            
                            	BeginTxWithReadUncommitted() *sql.Tx
                            	BeginTxWithReadCommitted() *sql.Tx
                            	BeginTxWithRepeatableRead() *sql.Tx
                            	BeginTx() *sql.Tx
                            	BeginTxWithLevel(level sql.IsolationLevel) *sql.Tx
                            
                            	BeginTxWithReadUncommittedAndConnection(conn string) *sql.Tx
                            	BeginTxWithReadCommittedAndConnection(conn string) *sql.Tx
                            	BeginTxWithRepeatableReadAndConnection(conn string) *sql.Tx
                            	BeginTxAndConnection(conn string) *sql.Tx
                            	BeginTxWithLevelAndConnection(conn string, level sql.IsolationLevel) *sql.Tx
                            
                            	// InitDB initialize the database connections.
                            	InitDB(cfg map[string]config.Database) Connection
                            
                            	// GetName get the connection name.
                            	Name() string
                            
                            	Close() []error
                            
                            	GetDelimiter() string
                            	GetDelimiter2() string
                            	GetDelimiters() []string
                            
                            	GetDB(key string) *sql.DB
                            
                            	GetConfig(name string) config.Database
                            
                            	CreateDB(name string, beans ...interface{}) error
                            }

                              Connection is a connection handler of database.

                              func GetConnection

                              func GetConnection(srvs service.List) Connection

                              func GetConnectionByDriver

                              func GetConnectionByDriver(driver string) Connection

                                GetConnectionByDriver return the Connection by given driver name.

                                func GetConnectionFromService

                                func GetConnectionFromService(srv interface{}) Connection

                                type DatabaseType

                                type DatabaseType string

                                  DatabaseType is the database field type.

                                  const (
                                  	Int       DatabaseType = "INT"
                                  	Tinyint   DatabaseType = "TINYINT"
                                  	Mediumint DatabaseType = "MEDIUMINT"
                                  	Smallint  DatabaseType = "SMALLINT"
                                  	Bigint    DatabaseType = "BIGINT"
                                  	Bit       DatabaseType = "BIT"
                                  	Int8      DatabaseType = "INT8"
                                  	Int4      DatabaseType = "INT4"
                                  	Int2      DatabaseType = "INT2"
                                  
                                  	Integer     DatabaseType = "INTEGER"
                                  	Numeric     DatabaseType = "NUMERIC"
                                  	Smallserial DatabaseType = "SMALLSERIAL"
                                  	Serial      DatabaseType = "SERIAL"
                                  	Bigserial   DatabaseType = "BIGSERIAL"
                                  	Money       DatabaseType = "MONEY"
                                  
                                  	Real    DatabaseType = "REAL"
                                  	Float   DatabaseType = "FLOAT"
                                  	Float4  DatabaseType = "FLOAT4"
                                  	Float8  DatabaseType = "FLOAT8"
                                  	Double  DatabaseType = "DOUBLE"
                                  	Decimal DatabaseType = "DECIMAL"
                                  
                                  	Doubleprecision DatabaseType = "DOUBLEPRECISION"
                                  
                                  	Date      DatabaseType = "DATE"
                                  	Time      DatabaseType = "TIME"
                                  	Year      DatabaseType = "YEAR"
                                  	Datetime  DatabaseType = "DATETIME"
                                  	Timestamp DatabaseType = "TIMESTAMP"
                                  
                                  	Text       DatabaseType = "TEXT"
                                  	Longtext   DatabaseType = "LONGTEXT"
                                  	Mediumtext DatabaseType = "MEDIUMTEXT"
                                  	Tinytext   DatabaseType = "TINYTEXT"
                                  
                                  	Varchar DatabaseType = "VARCHAR"
                                  	Char    DatabaseType = "CHAR"
                                  	Bpchar  DatabaseType = "BPCHAR"
                                  	JSON    DatabaseType = "JSON"
                                  
                                  	Blob       DatabaseType = "BLOB"
                                  	Tinyblob   DatabaseType = "TINYBLOB"
                                  	Mediumblob DatabaseType = "MEDIUMBLOB"
                                  	Longblob   DatabaseType = "LONGBLOB"
                                  
                                  	Interval DatabaseType = "INTERVAL"
                                  	Boolean  DatabaseType = "BOOLEAN"
                                  	Bool     DatabaseType = "BOOL"
                                  
                                  	Point   DatabaseType = "POINT"
                                  	Line    DatabaseType = "LINE"
                                  	Lseg    DatabaseType = "LSEG"
                                  	Box     DatabaseType = "BOX"
                                  	Path    DatabaseType = "PATH"
                                  	Polygon DatabaseType = "POLYGON"
                                  	Circle  DatabaseType = "CIRCLE"
                                  
                                  	Cidr    DatabaseType = "CIDR"
                                  	Inet    DatabaseType = "INET"
                                  	Macaddr DatabaseType = "MACADDR"
                                  
                                  	Character        DatabaseType = "CHARACTER"
                                  	Varyingcharacter DatabaseType = "VARYINGCHARACTER"
                                  	Nchar            DatabaseType = "NCHAR"
                                  	Nativecharacter  DatabaseType = "NATIVECHARACTER"
                                  	Nvarchar         DatabaseType = "NVARCHAR"
                                  	Clob             DatabaseType = "CLOB"
                                  
                                  	Binary    DatabaseType = "BINARY"
                                  	Varbinary DatabaseType = "VARBINARY"
                                  	Enum      DatabaseType = "ENUM"
                                  	Set       DatabaseType = "SET"
                                  
                                  	Geometry DatabaseType = "GEOMETRY"
                                  
                                  	Multilinestring    DatabaseType = "MULTILINESTRING"
                                  	Multipolygon       DatabaseType = "MULTIPOLYGON"
                                  	Linestring         DatabaseType = "LINESTRING"
                                  	Multipoint         DatabaseType = "MULTIPOINT"
                                  	Geometrycollection DatabaseType = "GEOMETRYCOLLECTION"
                                  
                                  	Name DatabaseType = "NAME"
                                  	UUID DatabaseType = "UUID"
                                  
                                  	Timestamptz DatabaseType = "TIMESTAMPTZ"
                                  	Timetz      DatabaseType = "TIMETZ"
                                  )

                                  func DT

                                  func DT(s string) DatabaseType

                                    DT turn the string value into DatabaseType.

                                    func GetDTAndCheck

                                    func GetDTAndCheck(s string) DatabaseType

                                      GetDTAndCheck check the DatabaseType.

                                      type H

                                      type H map[string]interface{}

                                        H is a shorthand of map.

                                        type Mssql

                                        type Mssql struct {
                                        	Base
                                        }

                                          Mssql is a Connection of mssql.

                                          func GetMssqlDB

                                          func GetMssqlDB() *Mssql

                                            GetMssqlDB return the global mssql connection.

                                            func (*Mssql) BeginTx

                                            func (db *Mssql) BeginTx() *sql.Tx

                                              BeginTx starts a transaction with level LevelDefault.

                                              func (*Mssql) BeginTxAndConnection

                                              func (db *Mssql) BeginTxAndConnection(conn string) *sql.Tx

                                                BeginTxAndConnection starts a transaction with level LevelDefault and connection.

                                                func (*Mssql) BeginTxWithLevel

                                                func (db *Mssql) BeginTxWithLevel(level sql.IsolationLevel) *sql.Tx

                                                  BeginTxWithLevel starts a transaction with given transaction isolation level.

                                                  func (*Mssql) BeginTxWithLevelAndConnection

                                                  func (db *Mssql) BeginTxWithLevelAndConnection(conn string, level sql.IsolationLevel) *sql.Tx

                                                    BeginTxWithLevelAndConnection starts a transaction with given transaction isolation level and connection.

                                                    func (*Mssql) BeginTxWithReadCommitted

                                                    func (db *Mssql) BeginTxWithReadCommitted() *sql.Tx

                                                      BeginTxWithReadCommitted starts a transaction with level LevelReadCommitted.

                                                      func (*Mssql) BeginTxWithReadCommittedAndConnection

                                                      func (db *Mssql) BeginTxWithReadCommittedAndConnection(conn string) *sql.Tx

                                                        BeginTxWithReadCommittedAndConnection starts a transaction with level LevelReadCommitted and connection.

                                                        func (*Mssql) BeginTxWithReadUncommitted

                                                        func (db *Mssql) BeginTxWithReadUncommitted() *sql.Tx

                                                          BeginTxWithReadUncommitted starts a transaction with level LevelReadUncommitted.

                                                          func (*Mssql) BeginTxWithReadUncommittedAndConnection

                                                          func (db *Mssql) BeginTxWithReadUncommittedAndConnection(conn string) *sql.Tx

                                                            BeginTxWithReadUncommittedAndConnection starts a transaction with level LevelReadUncommitted and connection.

                                                            func (*Mssql) BeginTxWithRepeatableRead

                                                            func (db *Mssql) BeginTxWithRepeatableRead() *sql.Tx

                                                              BeginTxWithRepeatableRead starts a transaction with level LevelRepeatableRead.

                                                              func (*Mssql) BeginTxWithRepeatableReadAndConnection

                                                              func (db *Mssql) BeginTxWithRepeatableReadAndConnection(conn string) *sql.Tx

                                                                BeginTxWithRepeatableReadAndConnection starts a transaction with level LevelRepeatableRead and connection.

                                                                func (*Mssql) Exec

                                                                func (db *Mssql) Exec(query string, args ...interface{}) (sql.Result, error)

                                                                  Exec implements the method Connection.Exec.

                                                                  func (*Mssql) ExecWith

                                                                  func (db *Mssql) ExecWith(tx *sql.Tx, conn, query string, args ...interface{}) (sql.Result, error)

                                                                  func (*Mssql) ExecWithConnection

                                                                  func (db *Mssql) ExecWithConnection(con string, query string, args ...interface{}) (sql.Result, error)

                                                                    ExecWithConnection implements the method Connection.ExecWithConnection.

                                                                    func (*Mssql) ExecWithTx

                                                                    func (db *Mssql) ExecWithTx(tx *sql.Tx, query string, args ...interface{}) (sql.Result, error)

                                                                      ExecWithTx is exec method within the transaction.

                                                                      func (*Mssql) GetDelimiter

                                                                      func (db *Mssql) GetDelimiter() string

                                                                        GetDelimiter implements the method Connection.GetDelimiter.

                                                                        func (*Mssql) GetDelimiter2

                                                                        func (db *Mssql) GetDelimiter2() string

                                                                          GetDelimiter2 implements the method Connection.GetDelimiter2.

                                                                          func (*Mssql) GetDelimiters

                                                                          func (db *Mssql) GetDelimiters() []string

                                                                            GetDelimiters implements the method Connection.GetDelimiters.

                                                                            func (*Mssql) InitDB

                                                                            func (db *Mssql) InitDB(cfgs map[string]config.Database) Connection

                                                                              InitDB implements the method Connection.InitDB.

                                                                              func (*Mssql) Name

                                                                              func (db *Mssql) Name() string

                                                                                Name implements the method Connection.Name.

                                                                                func (*Mssql) Query

                                                                                func (db *Mssql) Query(query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                  Query implements the method Connection.Query.

                                                                                  func (*Mssql) QueryWith

                                                                                  func (db *Mssql) QueryWith(tx *sql.Tx, conn, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                  func (*Mssql) QueryWithConnection

                                                                                  func (db *Mssql) QueryWithConnection(con string, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                    QueryWithConnection implements the method Connection.QueryWithConnection.

                                                                                    func (*Mssql) QueryWithTx

                                                                                    func (db *Mssql) QueryWithTx(tx *sql.Tx, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                      QueryWithTx is query method within the transaction.

                                                                                      type Mysql

                                                                                      type Mysql struct {
                                                                                      	Base
                                                                                      }

                                                                                        Mysql is a Connection of mysql.

                                                                                        func GetMysqlDB

                                                                                        func GetMysqlDB() *Mysql

                                                                                          GetMysqlDB return the global mysql connection.

                                                                                          func (*Mysql) BeginTx

                                                                                          func (db *Mysql) BeginTx() *sql.Tx

                                                                                            BeginTx starts a transaction with level LevelDefault.

                                                                                            func (*Mysql) BeginTxAndConnection

                                                                                            func (db *Mysql) BeginTxAndConnection(conn string) *sql.Tx

                                                                                              BeginTxAndConnection starts a transaction with level LevelDefault and connection.

                                                                                              func (*Mysql) BeginTxWithLevel

                                                                                              func (db *Mysql) BeginTxWithLevel(level sql.IsolationLevel) *sql.Tx

                                                                                                BeginTxWithLevel starts a transaction with given transaction isolation level.

                                                                                                func (*Mysql) BeginTxWithLevelAndConnection

                                                                                                func (db *Mysql) BeginTxWithLevelAndConnection(conn string, level sql.IsolationLevel) *sql.Tx

                                                                                                  BeginTxWithLevelAndConnection starts a transaction with given transaction isolation level and connection.

                                                                                                  func (*Mysql) BeginTxWithReadCommitted

                                                                                                  func (db *Mysql) BeginTxWithReadCommitted() *sql.Tx

                                                                                                    BeginTxWithReadCommitted starts a transaction with level LevelReadCommitted.

                                                                                                    func (*Mysql) BeginTxWithReadCommittedAndConnection

                                                                                                    func (db *Mysql) BeginTxWithReadCommittedAndConnection(conn string) *sql.Tx

                                                                                                      BeginTxWithReadCommittedAndConnection starts a transaction with level LevelReadCommitted and connection.

                                                                                                      func (*Mysql) BeginTxWithReadUncommitted

                                                                                                      func (db *Mysql) BeginTxWithReadUncommitted() *sql.Tx

                                                                                                        BeginTxWithReadUncommitted starts a transaction with level LevelReadUncommitted.

                                                                                                        func (*Mysql) BeginTxWithReadUncommittedAndConnection

                                                                                                        func (db *Mysql) BeginTxWithReadUncommittedAndConnection(conn string) *sql.Tx

                                                                                                          BeginTxWithReadUncommittedAndConnection starts a transaction with level LevelReadUncommitted and connection.

                                                                                                          func (*Mysql) BeginTxWithRepeatableRead

                                                                                                          func (db *Mysql) BeginTxWithRepeatableRead() *sql.Tx

                                                                                                            BeginTxWithRepeatableRead starts a transaction with level LevelRepeatableRead.

                                                                                                            func (*Mysql) BeginTxWithRepeatableReadAndConnection

                                                                                                            func (db *Mysql) BeginTxWithRepeatableReadAndConnection(conn string) *sql.Tx

                                                                                                              BeginTxWithRepeatableReadAndConnection starts a transaction with level LevelRepeatableRead and connection.

                                                                                                              func (*Mysql) Exec

                                                                                                              func (db *Mysql) Exec(query string, args ...interface{}) (sql.Result, error)

                                                                                                                Exec implements the method Connection.Exec.

                                                                                                                func (*Mysql) ExecWith

                                                                                                                func (db *Mysql) ExecWith(tx *sql.Tx, conn, query string, args ...interface{}) (sql.Result, error)

                                                                                                                func (*Mysql) ExecWithConnection

                                                                                                                func (db *Mysql) ExecWithConnection(con string, query string, args ...interface{}) (sql.Result, error)

                                                                                                                  ExecWithConnection implements the method Connection.ExecWithConnection.

                                                                                                                  func (*Mysql) ExecWithTx

                                                                                                                  func (db *Mysql) ExecWithTx(tx *sql.Tx, query string, args ...interface{}) (sql.Result, error)

                                                                                                                    ExecWithTx is exec method within the transaction.

                                                                                                                    func (*Mysql) GetDelimiter

                                                                                                                    func (db *Mysql) GetDelimiter() string

                                                                                                                      GetDelimiter implements the method Connection.GetDelimiter.

                                                                                                                      func (*Mysql) GetDelimiter2

                                                                                                                      func (db *Mysql) GetDelimiter2() string

                                                                                                                        GetDelimiter2 implements the method Connection.GetDelimiter2.

                                                                                                                        func (*Mysql) GetDelimiters

                                                                                                                        func (db *Mysql) GetDelimiters() []string

                                                                                                                          GetDelimiters implements the method Connection.GetDelimiters.

                                                                                                                          func (*Mysql) InitDB

                                                                                                                          func (db *Mysql) InitDB(cfgs map[string]config.Database) Connection

                                                                                                                            InitDB implements the method Connection.InitDB.

                                                                                                                            func (*Mysql) Name

                                                                                                                            func (db *Mysql) Name() string

                                                                                                                              Name implements the method Connection.Name.

                                                                                                                              func (*Mysql) Query

                                                                                                                              func (db *Mysql) Query(query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                Query implements the method Connection.Query.

                                                                                                                                func (*Mysql) QueryWith

                                                                                                                                func (db *Mysql) QueryWith(tx *sql.Tx, conn, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                func (*Mysql) QueryWithConnection

                                                                                                                                func (db *Mysql) QueryWithConnection(con string, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                  QueryWithConnection implements the method Connection.QueryWithConnection.

                                                                                                                                  func (*Mysql) QueryWithTx

                                                                                                                                  func (db *Mysql) QueryWithTx(tx *sql.Tx, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                    QueryWithTx is query method within the transaction.

                                                                                                                                    type Postgresql

                                                                                                                                    type Postgresql struct {
                                                                                                                                    	Base
                                                                                                                                    }

                                                                                                                                      Postgresql is a Connection of postgresql.

                                                                                                                                      func GetPostgresqlDB

                                                                                                                                      func GetPostgresqlDB() *Postgresql

                                                                                                                                        GetPostgresqlDB return the global postgresql connection.

                                                                                                                                        func (*Postgresql) BeginTx

                                                                                                                                        func (db *Postgresql) BeginTx() *sql.Tx

                                                                                                                                          BeginTx starts a transaction with level LevelDefault.

                                                                                                                                          func (*Postgresql) BeginTxAndConnection

                                                                                                                                          func (db *Postgresql) BeginTxAndConnection(conn string) *sql.Tx

                                                                                                                                            BeginTxAndConnection starts a transaction with level LevelDefault and connection.

                                                                                                                                            func (*Postgresql) BeginTxWithLevel

                                                                                                                                            func (db *Postgresql) BeginTxWithLevel(level sql.IsolationLevel) *sql.Tx

                                                                                                                                              BeginTxWithLevel starts a transaction with given transaction isolation level.

                                                                                                                                              func (*Postgresql) BeginTxWithLevelAndConnection

                                                                                                                                              func (db *Postgresql) BeginTxWithLevelAndConnection(conn string, level sql.IsolationLevel) *sql.Tx

                                                                                                                                                BeginTxWithLevelAndConnection starts a transaction with given transaction isolation level and connection.

                                                                                                                                                func (*Postgresql) BeginTxWithReadCommitted

                                                                                                                                                func (db *Postgresql) BeginTxWithReadCommitted() *sql.Tx

                                                                                                                                                  BeginTxWithReadCommitted starts a transaction with level LevelReadCommitted.

                                                                                                                                                  func (*Postgresql) BeginTxWithReadCommittedAndConnection

                                                                                                                                                  func (db *Postgresql) BeginTxWithReadCommittedAndConnection(conn string) *sql.Tx

                                                                                                                                                    BeginTxWithReadCommittedAndConnection starts a transaction with level LevelReadCommitted and connection.

                                                                                                                                                    func (*Postgresql) BeginTxWithReadUncommitted

                                                                                                                                                    func (db *Postgresql) BeginTxWithReadUncommitted() *sql.Tx

                                                                                                                                                      BeginTxWithReadUncommitted starts a transaction with level LevelReadUncommitted.

                                                                                                                                                      func (*Postgresql) BeginTxWithReadUncommittedAndConnection

                                                                                                                                                      func (db *Postgresql) BeginTxWithReadUncommittedAndConnection(conn string) *sql.Tx

                                                                                                                                                        BeginTxWithReadUncommittedAndConnection starts a transaction with level LevelReadUncommitted and connection.

                                                                                                                                                        func (*Postgresql) BeginTxWithRepeatableRead

                                                                                                                                                        func (db *Postgresql) BeginTxWithRepeatableRead() *sql.Tx

                                                                                                                                                          BeginTxWithRepeatableRead starts a transaction with level LevelRepeatableRead.

                                                                                                                                                          func (*Postgresql) BeginTxWithRepeatableReadAndConnection

                                                                                                                                                          func (db *Postgresql) BeginTxWithRepeatableReadAndConnection(conn string) *sql.Tx

                                                                                                                                                            BeginTxWithRepeatableReadAndConnection starts a transaction with level LevelRepeatableRead and connection.

                                                                                                                                                            func (*Postgresql) Exec

                                                                                                                                                            func (db *Postgresql) Exec(query string, args ...interface{}) (sql.Result, error)

                                                                                                                                                              Exec implements the method Connection.Exec.

                                                                                                                                                              func (*Postgresql) ExecWith

                                                                                                                                                              func (db *Postgresql) ExecWith(tx *sql.Tx, conn, query string, args ...interface{}) (sql.Result, error)

                                                                                                                                                              func (*Postgresql) ExecWithConnection

                                                                                                                                                              func (db *Postgresql) ExecWithConnection(con string, query string, args ...interface{}) (sql.Result, error)

                                                                                                                                                                ExecWithConnection implements the method Connection.ExecWithConnection.

                                                                                                                                                                func (*Postgresql) ExecWithTx

                                                                                                                                                                func (db *Postgresql) ExecWithTx(tx *sql.Tx, query string, args ...interface{}) (sql.Result, error)

                                                                                                                                                                  ExecWithTx is exec method within the transaction.

                                                                                                                                                                  func (*Postgresql) GetDelimiter

                                                                                                                                                                  func (db *Postgresql) GetDelimiter() string

                                                                                                                                                                    GetDelimiter implements the method Connection.GetDelimiter.

                                                                                                                                                                    func (*Postgresql) GetDelimiter2

                                                                                                                                                                    func (db *Postgresql) GetDelimiter2() string

                                                                                                                                                                      GetDelimiter2 implements the method Connection.GetDelimiter2.

                                                                                                                                                                      func (*Postgresql) GetDelimiters

                                                                                                                                                                      func (db *Postgresql) GetDelimiters() []string

                                                                                                                                                                        GetDelimiters implements the method Connection.GetDelimiters.

                                                                                                                                                                        func (*Postgresql) InitDB

                                                                                                                                                                        func (db *Postgresql) InitDB(cfgList map[string]config.Database) Connection

                                                                                                                                                                          InitDB implements the method Connection.InitDB.

                                                                                                                                                                          func (*Postgresql) Name

                                                                                                                                                                          func (db *Postgresql) Name() string

                                                                                                                                                                            Name implements the method Connection.Name.

                                                                                                                                                                            func (*Postgresql) Query

                                                                                                                                                                            func (db *Postgresql) Query(query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                              Query implements the method Connection.Query.

                                                                                                                                                                              func (*Postgresql) QueryWith

                                                                                                                                                                              func (db *Postgresql) QueryWith(tx *sql.Tx, conn, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                              func (*Postgresql) QueryWithConnection

                                                                                                                                                                              func (db *Postgresql) QueryWithConnection(con string, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                                QueryWithConnection implements the method Connection.QueryWithConnection.

                                                                                                                                                                                func (*Postgresql) QueryWithTx

                                                                                                                                                                                func (db *Postgresql) QueryWithTx(tx *sql.Tx, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                                  QueryWithTx is query method within the transaction.

                                                                                                                                                                                  type SQL

                                                                                                                                                                                  type SQL struct {
                                                                                                                                                                                  	dialect.SQLComponent
                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                  }

                                                                                                                                                                                    SQL wraps the Connection and driver dialect methods.

                                                                                                                                                                                    func Table

                                                                                                                                                                                    func Table(table string) *SQL

                                                                                                                                                                                      TableName return a SQL with given table and default connection.

                                                                                                                                                                                      func WithDriver

                                                                                                                                                                                      func WithDriver(conn Connection) *SQL

                                                                                                                                                                                        WithDriver return a SQL with given driver.

                                                                                                                                                                                        func WithDriverAndConnection

                                                                                                                                                                                        func WithDriverAndConnection(connName string, conn Connection) *SQL

                                                                                                                                                                                          WithDriverAndConnection return a SQL with given driver and connection name.

                                                                                                                                                                                          func (*SQL) All

                                                                                                                                                                                          func (sql *SQL) All() ([]map[string]interface{}, error)

                                                                                                                                                                                            All query all the result and return.

                                                                                                                                                                                            func (*SQL) Avg

                                                                                                                                                                                            func (sql *SQL) Avg(field string) (interface{}, error)

                                                                                                                                                                                              Avg find the average value of given field.

                                                                                                                                                                                              func (*SQL) Count

                                                                                                                                                                                              func (sql *SQL) Count() (int64, error)

                                                                                                                                                                                                Count query the count of query results.

                                                                                                                                                                                                func (*SQL) Delete

                                                                                                                                                                                                func (sql *SQL) Delete() error

                                                                                                                                                                                                  Delete exec the delete method.

                                                                                                                                                                                                  func (*SQL) Exec

                                                                                                                                                                                                  func (sql *SQL) Exec() (int64, error)

                                                                                                                                                                                                    Exec exec the exec method.

                                                                                                                                                                                                    func (*SQL) Find

                                                                                                                                                                                                    func (sql *SQL) Find(arg interface{}) (map[string]interface{}, error)

                                                                                                                                                                                                      Find query the sql result with given id assuming that primary key name is "id".

                                                                                                                                                                                                      func (*SQL) First

                                                                                                                                                                                                      func (sql *SQL) First() (map[string]interface{}, error)

                                                                                                                                                                                                        First query the result and return the first row.

                                                                                                                                                                                                        func (*SQL) GroupBy

                                                                                                                                                                                                        func (sql *SQL) GroupBy(fields ...string) *SQL

                                                                                                                                                                                                        func (*SQL) GroupByRaw

                                                                                                                                                                                                        func (sql *SQL) GroupByRaw(group string) *SQL

                                                                                                                                                                                                          GroupByRaw set group by.

                                                                                                                                                                                                          func (*SQL) Insert

                                                                                                                                                                                                          func (sql *SQL) Insert(values dialect.H) (int64, error)

                                                                                                                                                                                                            Insert exec the insert method of given key/value pairs.

                                                                                                                                                                                                            func (*SQL) LeftJoin

                                                                                                                                                                                                            func (sql *SQL) LeftJoin(table string, fieldA string, operation string, fieldB string) *SQL

                                                                                                                                                                                                              LeftJoin add a left join info.

                                                                                                                                                                                                              func (*SQL) Max

                                                                                                                                                                                                              func (sql *SQL) Max(field string) (interface{}, error)

                                                                                                                                                                                                                Max find the maximal value of given field.

                                                                                                                                                                                                                func (*SQL) Min

                                                                                                                                                                                                                func (sql *SQL) Min(field string) (interface{}, error)

                                                                                                                                                                                                                  Min find the minimal value of given field.

                                                                                                                                                                                                                  func (*SQL) OrderBy

                                                                                                                                                                                                                  func (sql *SQL) OrderBy(fields ...string) *SQL

                                                                                                                                                                                                                    OrderBy set order fields.

                                                                                                                                                                                                                    func (*SQL) OrderByRaw

                                                                                                                                                                                                                    func (sql *SQL) OrderByRaw(order string) *SQL

                                                                                                                                                                                                                      OrderByRaw set order by.

                                                                                                                                                                                                                      func (*SQL) Select

                                                                                                                                                                                                                      func (sql *SQL) Select(fields ...string) *SQL

                                                                                                                                                                                                                        Select set select fields.

                                                                                                                                                                                                                        func (*SQL) ShowColumns

                                                                                                                                                                                                                        func (sql *SQL) ShowColumns() ([]map[string]interface{}, error)

                                                                                                                                                                                                                          ShowColumns show columns info.

                                                                                                                                                                                                                          func (*SQL) ShowTables

                                                                                                                                                                                                                          func (sql *SQL) ShowTables() ([]string, error)

                                                                                                                                                                                                                            ShowTables show table info.

                                                                                                                                                                                                                            func (*SQL) Skip

                                                                                                                                                                                                                            func (sql *SQL) Skip(offset int) *SQL

                                                                                                                                                                                                                              Skip set offset value.

                                                                                                                                                                                                                              func (*SQL) Sum

                                                                                                                                                                                                                              func (sql *SQL) Sum(field string) (float64, error)

                                                                                                                                                                                                                                Sum sum the value of given field.

                                                                                                                                                                                                                                func (*SQL) Table

                                                                                                                                                                                                                                func (sql *SQL) Table(table string) *SQL

                                                                                                                                                                                                                                  TableName set table of SQL.

                                                                                                                                                                                                                                  func (*SQL) Take

                                                                                                                                                                                                                                  func (sql *SQL) Take(take int) *SQL

                                                                                                                                                                                                                                    Take set limit value.

                                                                                                                                                                                                                                    func (*SQL) Update

                                                                                                                                                                                                                                    func (sql *SQL) Update(values dialect.H) (int64, error)

                                                                                                                                                                                                                                      Update exec the update method of given key/value pairs.

                                                                                                                                                                                                                                      func (*SQL) UpdateRaw

                                                                                                                                                                                                                                      func (sql *SQL) UpdateRaw(raw string, args ...interface{}) *SQL

                                                                                                                                                                                                                                        UpdateRaw set UpdateRaw.

                                                                                                                                                                                                                                        func (*SQL) Where

                                                                                                                                                                                                                                        func (sql *SQL) Where(field string, operation string, arg interface{}) *SQL

                                                                                                                                                                                                                                          Where add the where operation and argument value.

                                                                                                                                                                                                                                          func (*SQL) WhereIn

                                                                                                                                                                                                                                          func (sql *SQL) WhereIn(field string, arg []interface{}) *SQL

                                                                                                                                                                                                                                            WhereIn add the where operation of "in" and argument values.

                                                                                                                                                                                                                                            func (*SQL) WhereNotIn

                                                                                                                                                                                                                                            func (sql *SQL) WhereNotIn(field string, arg []interface{}) *SQL

                                                                                                                                                                                                                                              WhereNotIn add the where operation of "not in" and argument values.

                                                                                                                                                                                                                                              func (*SQL) WhereRaw

                                                                                                                                                                                                                                              func (sql *SQL) WhereRaw(raw string, args ...interface{}) *SQL

                                                                                                                                                                                                                                                WhereRaw set WhereRaws and arguments.

                                                                                                                                                                                                                                                func (*SQL) WithConnection

                                                                                                                                                                                                                                                func (sql *SQL) WithConnection(conn string) *SQL

                                                                                                                                                                                                                                                  WithConnection set the connection name of SQL.

                                                                                                                                                                                                                                                  func (*SQL) WithDriver

                                                                                                                                                                                                                                                  func (sql *SQL) WithDriver(conn Connection) *SQL

                                                                                                                                                                                                                                                    WithDriver return a SQL with given driver.

                                                                                                                                                                                                                                                    func (*SQL) WithTransaction

                                                                                                                                                                                                                                                    func (sql *SQL) WithTransaction(fn TxFn) (res map[string]interface{}, err error)

                                                                                                                                                                                                                                                      WithTransaction call the callback function within the transaction and catch the error.

                                                                                                                                                                                                                                                      func (*SQL) WithTransactionByLevel

                                                                                                                                                                                                                                                      func (sql *SQL) WithTransactionByLevel(level dbsql.IsolationLevel, fn TxFn) (res map[string]interface{}, err error)

                                                                                                                                                                                                                                                        WithTransactionByLevel call the callback function within the transaction of given transaction level and catch the error.

                                                                                                                                                                                                                                                        func (*SQL) WithTx

                                                                                                                                                                                                                                                        func (sql *SQL) WithTx(tx *dbsql.Tx) *SQL

                                                                                                                                                                                                                                                          WithTx set the database transaction object of SQL.

                                                                                                                                                                                                                                                          type SQLTx

                                                                                                                                                                                                                                                          type SQLTx struct {
                                                                                                                                                                                                                                                          	Tx *sql.Tx
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            SQLTx is an in-progress database transaction.

                                                                                                                                                                                                                                                            type Sqlite

                                                                                                                                                                                                                                                            type Sqlite struct {
                                                                                                                                                                                                                                                            	Base
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              Sqlite is a Connection of sqlite.

                                                                                                                                                                                                                                                              func GetSqliteDB

                                                                                                                                                                                                                                                              func GetSqliteDB() *Sqlite

                                                                                                                                                                                                                                                                GetSqliteDB return the global sqlite connection.

                                                                                                                                                                                                                                                                func (*Sqlite) BeginTx

                                                                                                                                                                                                                                                                func (db *Sqlite) BeginTx() *sql.Tx

                                                                                                                                                                                                                                                                  BeginTx starts a transaction with level LevelDefault.

                                                                                                                                                                                                                                                                  func (*Sqlite) BeginTxAndConnection

                                                                                                                                                                                                                                                                  func (db *Sqlite) BeginTxAndConnection(conn string) *sql.Tx

                                                                                                                                                                                                                                                                    BeginTxAndConnection starts a transaction with level LevelDefault and connection.

                                                                                                                                                                                                                                                                    func (*Sqlite) BeginTxWithLevel

                                                                                                                                                                                                                                                                    func (db *Sqlite) BeginTxWithLevel(level sql.IsolationLevel) *sql.Tx

                                                                                                                                                                                                                                                                      BeginTxWithLevel starts a transaction with given transaction isolation level.

                                                                                                                                                                                                                                                                      func (*Sqlite) BeginTxWithLevelAndConnection

                                                                                                                                                                                                                                                                      func (db *Sqlite) BeginTxWithLevelAndConnection(conn string, level sql.IsolationLevel) *sql.Tx

                                                                                                                                                                                                                                                                        BeginTxWithLevelAndConnection starts a transaction with given transaction isolation level and connection.

                                                                                                                                                                                                                                                                        func (*Sqlite) BeginTxWithReadCommitted

                                                                                                                                                                                                                                                                        func (db *Sqlite) BeginTxWithReadCommitted() *sql.Tx

                                                                                                                                                                                                                                                                          BeginTxWithReadCommitted starts a transaction with level LevelReadCommitted.

                                                                                                                                                                                                                                                                          func (*Sqlite) BeginTxWithReadCommittedAndConnection

                                                                                                                                                                                                                                                                          func (db *Sqlite) BeginTxWithReadCommittedAndConnection(conn string) *sql.Tx

                                                                                                                                                                                                                                                                            BeginTxWithReadCommittedAndConnection starts a transaction with level LevelReadCommitted and connection.

                                                                                                                                                                                                                                                                            func (*Sqlite) BeginTxWithReadUncommitted

                                                                                                                                                                                                                                                                            func (db *Sqlite) BeginTxWithReadUncommitted() *sql.Tx

                                                                                                                                                                                                                                                                              BeginTxWithReadUncommitted starts a transaction with level LevelReadUncommitted.

                                                                                                                                                                                                                                                                              func (*Sqlite) BeginTxWithReadUncommittedAndConnection

                                                                                                                                                                                                                                                                              func (db *Sqlite) BeginTxWithReadUncommittedAndConnection(conn string) *sql.Tx

                                                                                                                                                                                                                                                                                BeginTxWithReadUncommittedAndConnection starts a transaction with level LevelReadUncommitted and connection.

                                                                                                                                                                                                                                                                                func (*Sqlite) BeginTxWithRepeatableRead

                                                                                                                                                                                                                                                                                func (db *Sqlite) BeginTxWithRepeatableRead() *sql.Tx

                                                                                                                                                                                                                                                                                  BeginTxWithRepeatableRead starts a transaction with level LevelRepeatableRead.

                                                                                                                                                                                                                                                                                  func (*Sqlite) BeginTxWithRepeatableReadAndConnection

                                                                                                                                                                                                                                                                                  func (db *Sqlite) BeginTxWithRepeatableReadAndConnection(conn string) *sql.Tx

                                                                                                                                                                                                                                                                                    BeginTxWithRepeatableReadAndConnection starts a transaction with level LevelRepeatableRead and connection.

                                                                                                                                                                                                                                                                                    func (*Sqlite) Exec

                                                                                                                                                                                                                                                                                    func (db *Sqlite) Exec(query string, args ...interface{}) (sql.Result, error)

                                                                                                                                                                                                                                                                                      Exec implements the method Connection.Exec.

                                                                                                                                                                                                                                                                                      func (*Sqlite) ExecWith

                                                                                                                                                                                                                                                                                      func (db *Sqlite) ExecWith(tx *sql.Tx, conn, query string, args ...interface{}) (sql.Result, error)

                                                                                                                                                                                                                                                                                      func (*Sqlite) ExecWithConnection

                                                                                                                                                                                                                                                                                      func (db *Sqlite) ExecWithConnection(con string, query string, args ...interface{}) (sql.Result, error)

                                                                                                                                                                                                                                                                                        ExecWithConnection implements the method Connection.ExecWithConnection.

                                                                                                                                                                                                                                                                                        func (*Sqlite) ExecWithTx

                                                                                                                                                                                                                                                                                        func (db *Sqlite) ExecWithTx(tx *sql.Tx, query string, args ...interface{}) (sql.Result, error)

                                                                                                                                                                                                                                                                                          ExecWithTx is exec method within the transaction.

                                                                                                                                                                                                                                                                                          func (*Sqlite) GetDelimiter

                                                                                                                                                                                                                                                                                          func (db *Sqlite) GetDelimiter() string

                                                                                                                                                                                                                                                                                            GetDelimiter implements the method Connection.GetDelimiter.

                                                                                                                                                                                                                                                                                            func (*Sqlite) GetDelimiter2

                                                                                                                                                                                                                                                                                            func (db *Sqlite) GetDelimiter2() string

                                                                                                                                                                                                                                                                                              GetDelimiter2 implements the method Connection.GetDelimiter2.

                                                                                                                                                                                                                                                                                              func (*Sqlite) GetDelimiters

                                                                                                                                                                                                                                                                                              func (db *Sqlite) GetDelimiters() []string

                                                                                                                                                                                                                                                                                                GetDelimiters implements the method Connection.GetDelimiters.

                                                                                                                                                                                                                                                                                                func (*Sqlite) InitDB

                                                                                                                                                                                                                                                                                                func (db *Sqlite) InitDB(cfgList map[string]config.Database) Connection

                                                                                                                                                                                                                                                                                                  InitDB implements the method Connection.InitDB.

                                                                                                                                                                                                                                                                                                  func (*Sqlite) Name

                                                                                                                                                                                                                                                                                                  func (db *Sqlite) Name() string

                                                                                                                                                                                                                                                                                                    Name implements the method Connection.Name.

                                                                                                                                                                                                                                                                                                    func (*Sqlite) Query

                                                                                                                                                                                                                                                                                                    func (db *Sqlite) Query(query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                                                                                                                                                      Query implements the method Connection.Query.

                                                                                                                                                                                                                                                                                                      func (*Sqlite) QueryWith

                                                                                                                                                                                                                                                                                                      func (db *Sqlite) QueryWith(tx *sql.Tx, conn, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                                                                                                                                                      func (*Sqlite) QueryWithConnection

                                                                                                                                                                                                                                                                                                      func (db *Sqlite) QueryWithConnection(con string, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                                                                                                                                                        QueryWithConnection implements the method Connection.QueryWithConnection.

                                                                                                                                                                                                                                                                                                        func (*Sqlite) QueryWithTx

                                                                                                                                                                                                                                                                                                        func (db *Sqlite) QueryWithTx(tx *sql.Tx, query string, args ...interface{}) ([]map[string]interface{}, error)

                                                                                                                                                                                                                                                                                                          QueryWithTx is query method within the transaction.

                                                                                                                                                                                                                                                                                                          type TxFn

                                                                                                                                                                                                                                                                                                          type TxFn func(tx *dbsql.Tx) (error, map[string]interface{})

                                                                                                                                                                                                                                                                                                            TxFn is the transaction callback function.

                                                                                                                                                                                                                                                                                                            type Value

                                                                                                                                                                                                                                                                                                            type Value string

                                                                                                                                                                                                                                                                                                              Value is a string.

                                                                                                                                                                                                                                                                                                              func GetValueFromDatabaseType

                                                                                                                                                                                                                                                                                                              func GetValueFromDatabaseType(typ DatabaseType, value interface{}, json bool) Value

                                                                                                                                                                                                                                                                                                              func GetValueFromJSONOfDatabaseType

                                                                                                                                                                                                                                                                                                              func GetValueFromJSONOfDatabaseType(typ DatabaseType, value interface{}) Value

                                                                                                                                                                                                                                                                                                                GetValueFromJSONOfDatabaseType return Value of given DatabaseType and interface from JSON string value.

                                                                                                                                                                                                                                                                                                                func GetValueFromSQLOfDatabaseType

                                                                                                                                                                                                                                                                                                                func GetValueFromSQLOfDatabaseType(typ DatabaseType, value interface{}) Value

                                                                                                                                                                                                                                                                                                                  GetValueFromDatabaseType return Value of given DatabaseType and interface.

                                                                                                                                                                                                                                                                                                                  func (Value) HTML

                                                                                                                                                                                                                                                                                                                  func (v Value) HTML() template.HTML

                                                                                                                                                                                                                                                                                                                    HTML return the template.HTML value.

                                                                                                                                                                                                                                                                                                                    func (Value) String

                                                                                                                                                                                                                                                                                                                    func (v Value) String() string

                                                                                                                                                                                                                                                                                                                      String return the string value.

                                                                                                                                                                                                                                                                                                                      func (Value) ToInt64

                                                                                                                                                                                                                                                                                                                      func (v Value) ToInt64() int64

                                                                                                                                                                                                                                                                                                                        ToInt64 turn the string to a int64.

                                                                                                                                                                                                                                                                                                                        Directories

                                                                                                                                                                                                                                                                                                                        Path Synopsis
                                                                                                                                                                                                                                                                                                                        drivers