xorm/xorm.go

package xorm

import (
	"database/sql"
	"errors"
	"fmt"
	"github.com/go-xorm/core"
	"os"
	"reflect"
	"runtime"
	"sync"
)

const (
	Version string = "0.4"
)

// !nashtsai! implicit register drivers and dialects is no good, as init() can be called before sql driver got registered
// func init() {
// 	regDrvsNDialects()
// }

func regDrvsNDialects() bool {
	if core.RegisteredDriverSize() == 0 {
		providedDrvsNDialects := map[string]struct {
			dbType     core.DbType
			getDriver  func() core.Driver
			getDialect func() core.Dialect
		}{
			"odbc":     {"mssql", func() core.Driver { return &odbcDriver{} }, func() core.Dialect { return &mssql{} }}, // !nashtsai! TODO change this when supporting MS Access
			"mysql":    {"mysql", func() core.Driver { return &mysqlDriver{} }, func() core.Dialect { return &mysql{} }},
			"mymysql":  {"mysql", func() core.Driver { return &mymysqlDriver{} }, func() core.Dialect { return &mysql{} }},
			"postgres": {"postgres", func() core.Driver { return &pqDriver{} }, func() core.Dialect { return &postgres{} }},
			"sqlite3":  {"sqlite3", func() core.Driver { return &sqlite3Driver{} }, func() core.Dialect { return &sqlite3{} }},
			"oci8":     {"oracle", func() core.Driver { return &oci8Driver{} }, func() core.Dialect { return &oracle{} }},
			"goracle":  {"oracle", func() core.Driver { return &goracleDriver{} }, func() core.Dialect { return &oracle{} }},
		}

		for driverName, v := range providedDrvsNDialects {
			_, err := sql.Open(driverName, "")
			if err == nil {
				// fmt.Printf("driver succeed: %v\n", driverName)
				core.RegisterDriver(driverName, v.getDriver())
				core.RegisterDialect(v.dbType, v.getDialect())
			} else {
				// fmt.Printf("driver failed: %v | err: %v\n", driverName, err)
			}
		}
		return true
	} else {
		return false
	}
}

func close(engine *Engine) {
	engine.Close()
}

// new a db manager according to the parameter. Currently support four
// drivers
func NewEngine(driverName string, dataSourceName string) (*Engine, error) {
	regDrvsNDialects()
	driver := core.QueryDriver(driverName)
	if driver == nil {
		return nil, errors.New(fmt.Sprintf("Unsupported driver name: %v", driverName))
	}

	uri, err := driver.Parse(driverName, dataSourceName)
	if err != nil {
		return nil, err
	}

	dialect := core.QueryDialect(uri.DbType)
	if dialect == nil {
		return nil, errors.New(fmt.Sprintf("Unsupported dialect type: %v", uri.DbType))
	}

	err = dialect.Init(uri, driverName, dataSourceName)
	if err != nil {
		return nil, err
	}

	db, err := core.OpenDialect(dialect)
	if err != nil {
		return nil, err
	}

	engine := &Engine{
		db:            db,
		dialect:       dialect,
		Tables:        make(map[reflect.Type]*core.Table),
		mutex:         &sync.RWMutex{},
		TagIdentifier: "xorm",
		Logger:        NewSimpleLogger(os.Stdout),
		TimeZone:      "Local",
	}

	engine.SetMapper(core.NewCacheMapper(new(core.SnakeMapper)))

	//engine.Filters = dialect.Filters()
	//engine.Cacher = NewLRUCacher()
	//err = engine.SetPool(NewSysConnectPool())

	runtime.SetFinalizer(engine, close)
	return engine, err
}

// clone an engine
func (engine *Engine) Clone() (*Engine, error) {
	return NewEngine(engine.dialect.DriverName(), engine.dialect.DataSourceName())
}