wego

第一种方式是使用worm.NewXXX()函数，该函数创建一个ORM引擎才，并返回*DbEngine，您需要自己管理该指针。
另外一种方式是使用worm.InitXXX函数，worm.InitXXX函数创建ORM引擎才，并将*DbEngine赋值给缺省的全局变量，您以后可以直接使用缺省全局变量来访问数据库。

创建MySQL数据库的DbEngine

您可通过调用worm.NewMysql()创建一个worm.DbEngine，或者通过调用worm.InitMysql()来初始化缺省的worm.DbEngine。


package main
import (
	"database/sql"
	"log"
	_ "github.com/go-sql-driver/mysql"
	"github.com/haming123/wego/worm"
)
func main() {
	cnnstr := "account:pwd@tcp(127.0.0.1:3306)/db?charset=utf8&parseTime=True"
	dbcnn, err := sql.Open("mysql", cnnstr)
	if err != nil {
		log.Println(err)
		return
	}
	err = dbcnn.Ping()
	if err != nil {
		log.Println(err)
		return
	}
	err = worm.InitMysql(dbcnn)
	if err != nil {
		log.Println(err)
		return
	}
}

创建PostgreSQL数据库的DbEngine

您可通过调用worm.NewPostgres()创建一个worm.DbEngine，或者通过调用worm.InitPostgres()来初始化缺省的worm.DbEngine。


package main
import (
	"database/sql"
	"log"
	_ "github.com/lib/pq"
	"github.com/haming123/wego/worm"
)
func main() {
	cnnstr := "host=127.0.0.1 port=5432 user=user_name password=pwd_str dbname=demo sslmode=disable"
	dbcnn, err := sql.Open("postgres", cnnstr)
	if err != nil {
		log.Println(err)
		return
	}
	err = dbcnn.Ping()
	if err != nil {
		log.Println(err)
		return
	}
	err = worm.InitPostgres(dbcnn)
	if err != nil {
		log.Println(err)
		return
	}
}

创建SQLServer数据库的DbEngine

您可通过调用worm.NewSqlServer()创建一个worm.DbEngine，或者通过调用worm.InitSqlServer()来初始化缺省的worm.DbEngine。


package main
import (
	"database/sql"
	"log"
	_ "github.com/denisenkom/go-mssqldb"
	"github.com/haming123/wego/worm"
)
func main() {
	cnnstr := "server=127.0.0.1;database=demo;user id=user_name;password=pwd_str;port=1433;encrypt=disable"
	dbcnn, err := sql.Open("mssql", cnnstr)
	if err != nil {
		log.Println(err)
		return
	}
	err = dbcnn.Ping()
	if err != nil {
		log.Println(err)
		return
	}
	err = worm.InitSqlServer(dbcnn)
	if err != nil {
		log.Println(err)
		return
	}
}

设置SQL日志的显示

worm缺省开启了SQL日志的输出，你可以调用worm.ShowSqlLog()来控制是否需要显示SQL日志：


err = worm.InitMysql(dbcnn)
if err != nil {
    log.Println(err)
    return
}
worm.ShowSqlLog(true)

开启全局预编译模式

worm支持SQL语句的预编译，使用SQL语句预编译可以提升数据库访问的效率。你可以调用worm.UsePrepare()来控制是否开启全局预编译：


err = worm.InitMysql(dbcnn)
if err != nil {
    log.Println(err)
    return
}
worm.UsePrepare(true)

添加从库

worm支持使用数据库的读写分离模式来访问一组数据库，您可以通过调用worm.AddSlave()来添加从库：


func initMySql(cnnstr string) (*sql.DB, error) {
	dbcnn, err := sql.Open("mysql", cnnstr)
	if err != nil {
		return nil, err
	}
	err = dbcnn.Ping()
	if err != nil {
		return nil, err
	}
	return dbcnn, nil
}

func main() {
	db, _ := initMySql("account:pwd@tcp(192.168.0.1:3306)/db?charset=utf8&parseTime=True")
	worm.InitMysql(db)
	db_slave1, _ := initMySql("account:pwd@tcp(192.168.0.2:3306)/db?charset=utf8&parseTime=True")
	worm.AddSlave(db_slave1, "slave1", 1)
	db_slave2, _ := initMySql("account:pwd@tcp(192.168.0.3:3306)/db?charset=utf8&parseTime=True")
	worm.AddSlave(db_slave2, "slave2", 1)
}

自定义引擎

worm目前支持的数据库类型有： MySQL, PostgreSQL, SQlite, SQLServer。对于不支持的数据库，您也可以自定义数据库引擎。

自定义数据库引擎，首先需要实现数据库方言接口，然后调用worm.NewEngine()函数或worm.InitEngine()函数来创建引擎。

数据库方言接口


type Dialect interface {
	GetName() string
	DbType2GoType(colType string) string
	GetColumns(db_raw *sql.DB, tableName string) ([]ColumnInfo, error)
	LimitSql(offset int64, limit int64) string
	ParsePlaceholder(sql_tpl string) string

	ModelInsertHasOutput(md *DbModel) bool
	GenModelInsertSql(md *DbModel) string
	GenModelUpdateSql(md *DbModel) string
	GenModelDeleteSql(md *DbModel) string
	GenModelGetSql(md *DbModel) string
	GenModelFindSql(md *DbModel) string

	TableInsertHasOutput(tb *DbTable) bool
	GenTableInsertSql(tb *DbTable) (string, []interface{})
	GenTableUpdateSql(tb *DbTable) (string, []interface{})
	GenTableDeleteSql(tb *DbTable) string
	GenTableGetSql(tb *DbTable) string
	GenTableFindSql(tb *DbTable) string

	GenJointGetSql(lk *DbJoint) string
	GenJointFindSql(lk *DbJoint) string
}

创建DbEngine

您可通过调用worm.NewEngine()创建一个worm.DbEngine，或者通过调用worm.InitEngine()来初始化缺省的worm.DbEngine。


package main
import (
	"database/sql"
	"log"
	"github.com/haming123/wego/worm"
)
func main() {
	dbcnn, err := sql.Open("数据库驱动名称", "数据库连接串")
	if err != nil {
		log.Println(err)
		return
	}
	err = dbcnn.Ping()
	if err != nil {
		log.Println(err)
		return
	}
    
	dialect := &UserDefinedDialect{}
	worm.InitEngine(dialect, dbcnn)
}