func NewTestEngine(x *xorm.Engine) (err error) { switch DbCfg.Type { case "mysql": x, err = xorm.NewEngine("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8", DbCfg.User, DbCfg.Pwd, DbCfg.Host, DbCfg.Name)) case "postgres": var host, port = "127.0.0.1", "5432" fields := strings.Split(DbCfg.Host, ":") if len(fields) > 0 && len(strings.TrimSpace(fields[0])) > 0 { host = fields[0] } if len(fields) > 1 && len(strings.TrimSpace(fields[1])) > 0 { port = fields[1] } cnnstr := fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s sslmode=%s", DbCfg.User, DbCfg.Pwd, host, port, DbCfg.Name, DbCfg.SslMode) //fmt.Println(cnnstr) x, err = xorm.NewEngine("postgres", cnnstr) case "sqlite3": if !EnableSQLite3 { return fmt.Errorf("Unknown database type: %s", DbCfg.Type) } os.MkdirAll(path.Dir(DbCfg.Path), os.ModePerm) x, err = xorm.NewEngine("sqlite3", DbCfg.Path) default: return fmt.Errorf("Unknown database type: %s", DbCfg.Type) } if err != nil { return fmt.Errorf("models.init(fail to conntect database): %v", err) } return x.Sync(tables...) }
func ConDb() (*xorm.Engine, error) { switch { case DataType == "memory": return xorm.NewEngine("tidb", "memory://tidb/tidb") case DataType == "goleveldb": return xorm.NewEngine("tidb", "goleveldb://./data/goleveldb") case DataType == "boltdb": return xorm.NewEngine("tidb", "boltdb://./data/boltdb") case DataType == "mysql": return xorm.NewEngine("mysql", "root:YouPass@/db?charset=utf8") //return xorm.NewEngine("mysql", "root:YouPass@/db?charset=utf8") case DataType == "postgres": return xorm.NewEngine("postgres", "user=postgres password=jn!@#$%^&* dbname=pgsql sslmode=disable") //return xorm.NewEngine("postgres", "user=postgres password=jn!@#$%^&* dbname=pgsql sslmode=disable") // "user=postgres password=jn!@#$%^&* dbname=yougam sslmode=disable maxcons=10 persist=true" //return xorm.NewEngine("postgres", "host=110.76.39.205 user=postgres password=jn!@#$%^&* dbname=yougam sslmode=disable") //return xorm.NewEngine("postgres", "host=127.0.0.1 port=6432 user=postgres password=jn!@#$%^&* dbname=yougam sslmode=disable") } return nil, errors.New("尚未设定数据库连接") }
func newTidbEngine(storeType string) (*xorm.Engine, error) { if storeType == "memory" { return xorm.NewEngine("tidb", storeType+"://tidb/tidb?parseTime=true") } os.Remove("./tidb_" + storeType) return xorm.NewEngine("tidb", storeType+"://./tidb_"+storeType+"/tidb?parseTime=true") }
func InitDB() (err error) { // utils.LoadConfig("conf/app.conf") utils.LoadConfig("conf/app-local.conf") // utils.LoadConfig("conf/app-skytap.conf") // appname = goTestLinkReport // httpport = 8080 // runmode = dev // appname = utils.Cfg.MustValue("server", key, ...) // dbtype = mysql // host = 127.0.0.1 // port = 3306 // name = report // user = root // pwd = 123123 // # SSLMODE = false dbtype := utils.Cfg.MustValue("db", "dbtype") host := utils.Cfg.MustValue("db", "host") port := utils.Cfg.MustValue("db", "port") name := utils.Cfg.MustValue("db", "name") user := utils.Cfg.MustValue("db", "user") pwd := utils.Cfg.MustValue("db", "pwd") ssl := utils.Cfg.MustValue("db", "ssl") switch dbtype { case "mysql": // connstr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8", // user, pwd, host, port, name) connstr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8", user, pwd, host, port, name) fmt.Errorf(connstr) orm, err = xorm.NewEngine("mysql", connstr) if err != nil { beego.Debug(fmt.Sprintf("Failed to create new engine : %v\n", err)) } case "postgres": cnnstr := fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s sslmode=%s", user, pwd, host, port, name, ssl) orm, err = xorm.NewEngine("postgres", cnnstr) default: beego.Debug(fmt.Sprintf("Unknown db type: %s\n", dbtype)) return fmt.Errorf("Unknown db type: %s\n", dbtype) } if err != nil { beego.Debug(fmt.Sprintf("models.init(failed to connect database): %v\n", err)) return fmt.Errorf("models.init(failed to connect database): %v\n", err) } // orm.ShowSQL = true // orm.ShowInfo = true // orm.ShowDebug = true // orm.ShowWarn = true orm.ShowErr = true fmt.Println("success!") return orm.Sync(tables...) }
func xConnDb() (*xorm.Engine, error) { switch DbType { case "sqlite": return xorm.NewEngine("sqlite3", filepath.Join(os.Getenv("GOPATH"), "src", "goAcq", "data", fmt.Sprintf("%s.db", DbName))) case "mysql": return xorm.NewEngine("mysql", fmt.Sprintf("%s:%s@tcp(%v)/%s?charset=%v", DbUser, DbPwd, DbHost, DbName, DbCharSet)) case "pgsql": return xorm.NewEngine("postgres", fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable", DbUser, DbPwd, DbName)) } return nil, fmt.Errorf("UnSopported database type: %v", DbType) }
func InitDB() (err error) { utils.LoadConfig("../conf/app.conf") dbtype := utils.Cfg.MustValue("db", "dbtype") host := utils.Cfg.MustValue("db", "host") port := utils.Cfg.MustValue("db", "port") name := utils.Cfg.MustValue("db", "name") user := utils.Cfg.MustValue("db", "user") pwd := utils.Cfg.MustValue("db", "pwd") ssl := utils.Cfg.MustValue("db", "ssl") switch dbtype { case "mysql": // connstr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8", // user, pwd, host, port, name) connstr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8", user, pwd, host, port, name) fmt.Errorf(connstr) orm, err = xorm.NewEngine("mysql", connstr) if err != nil { beego.Debug(fmt.Sprintf("Failed to create new engine : %v\n", err)) } case "postgres": cnnstr := fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s sslmode=%s", user, pwd, host, port, name, ssl) orm, err = xorm.NewEngine("postgres", cnnstr) default: beego.Debug(fmt.Sprintf("Unknown db type: %s\n", dbtype)) return fmt.Errorf("Unknown db type: %s\n", dbtype) } if err != nil { beego.Debug(fmt.Sprintf("models.init(failed to connect database): %v\n", err)) return fmt.Errorf("models.init(failed to connect database): %v\n", err) } // orm.ShowSQL = true // orm.ShowInfo = true // orm.ShowDebug = true // orm.ShowWarn = true orm.ShowErr = true orm.SetMapper(core.SameMapper{}) fmt.Println("success!") // return orm.Sync(tables...) err = orm.Sync(new(Test), new(PkgFunc)) if err != nil { fmt.Println("Failed to Sync()!") } return }
func ExampleRegisterStandardDatabases() { engine1, _ = xorm.NewEngine("mysql", "root:@/example_user?charset=utf8") engine2, _ = xorm.NewEngine("mysql", "root:@/example_user?charset=utf8") engine3, _ = xorm.NewEngine("mysql", "root:@/example_foobar?charset=utf8") engine4, _ = xorm.NewEngine("mysql", "root:@/example_other?charset=utf8") w = wizard.NewWizard() stndardCluster := w.CreateCluster(User{}, engine1) // engine is master database used for table of User{} stndardCluster.RegisterSlave(engine2) // add slave _ = w.CreateCluster("foobar", engine3) // engine3 is master database used for table of foobar stndardCluster = wizard.NewCluster(engine4) w.SetDefault(stndardCluster) // engine4 is master database used for all the other tables }
/** ** 初始化数据库连接 **/ func initDb() error { userName, err := util.GetValue("db", "userName") if err != nil { log.Fatalf("get value of userName from conf, %v", err) return err } pass, err := util.GetValue("db", "dbpass") if err != nil { log.Fatalf("get value of dbpass from conf, %v", err) return err } dbhost, err := util.GetValue("db", "dbhost") if err != nil { log.Fatalf("get value of dbhost from conf, %v", err) return err } dbport, err := util.GetValue("db", "dbport") if err != nil { log.Fatalf("get value of dbport from conf, %v", err) return err } dbname, err := util.GetValue("db", "dbname") if err != nil { log.Fatalf("get value of dbname from conf, %v", err) return err } dsn := []string{userName, ":", pass, "@tcp(", dbhost, ":", dbport, ")/", dbname} dsnStr := strings.Join(dsn, "") engine, err = xorm.NewEngine("mysql", dsnStr) return err }
func init() { // 创建 ORM 引擎与数据库 var err error x, err = xorm.NewEngine("sqlite3", "./bank.db") if err != nil { log.Fatalf("Fail to create engine: %v\n", err) } // 同步结构体与数据表 if err = x.Sync(new(Account)); err != nil { log.Fatalf("Fail to sync database: %v\n", err) } // 记录日志 f, err := os.Create("sql.log") if err != nil { log.Fatalf("Fail to create log file: %v\n", err) return } x.Logger = xorm.NewSimpleLogger(f) x.ShowSQL = true // 设置默认 LRU 缓存 cacher := xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000) x.SetDefaultCacher(cacher) }
//初始化数据库 func (api *Api) InitDB(database string) { var err error conf, err := ConfigFromFile(configPath) if err != nil { panic(err.Error()) } dbConf := conf.DataBase sqlUrl := fmt.Sprintf(dbConf.URL, dbConf.User, dbConf.Password, dbConf.Host, dbConf.Port, database) api.DB, err = xorm.NewEngine("mysql", sqlUrl) if err != nil { log.Fatalf("Got error when connect database, the error is '%v'", err) } api.DB.ShowSQL = true api.DB.ShowDebug = true api.DB.ShowErr = true api.DB.SetMaxIdleConns(dbConf.MaxIdleConnections) api.DB.SetMaxOpenConns(dbConf.MaxOpenConnections) //记录到日志文件中. // f, err := os.Create("sql.log") // if err != nil { // println(err.Error()) // return // } // defer f.Close() // api.DB.Logger = xorm.NewSimpleLogger(f) }
func getEngine() (*xorm.Engine, error) { cnnstr := "" switch DbCfg.Type { case "mysql": if DbCfg.Host[0] == '/' { // looks like a unix socket cnnstr = fmt.Sprintf("%s:%s@unix(%s)/%s?charset=utf8&parseTime=true", DbCfg.User, DbCfg.Passwd, DbCfg.Host, DbCfg.Name) } else { cnnstr = fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=true", DbCfg.User, DbCfg.Passwd, DbCfg.Host, DbCfg.Name) } case "postgres": var host, port = "127.0.0.1", "5432" fields := strings.Split(DbCfg.Host, ":") if len(fields) > 0 && len(strings.TrimSpace(fields[0])) > 0 { host = fields[0] } if len(fields) > 1 && len(strings.TrimSpace(fields[1])) > 0 { port = fields[1] } cnnstr = fmt.Sprintf("postgres://%s:%s@%s:%s/%s?sslmode=%s", url.QueryEscape(DbCfg.User), url.QueryEscape(DbCfg.Passwd), host, port, DbCfg.Name, DbCfg.SSLMode) case "sqlite3": if !EnableSQLite3 { return nil, fmt.Errorf("Unknown database type: %s", DbCfg.Type) } if err := os.MkdirAll(path.Dir(DbCfg.Path), os.ModePerm); err != nil { return nil, fmt.Errorf("Fail to create directories: %v", err) } cnnstr = "file:" + DbCfg.Path + "?cache=shared&mode=rwc" default: return nil, fmt.Errorf("Unknown database type: %s", DbCfg.Type) } return xorm.NewEngine(DbCfg.Type, cnnstr) }
// NewXormDBAppender create new db appender func NewXormDBAppender(driver, spec, table string) (*XormDBAppender, error) { if table == "" { table = "common_wlog" } wlog.DB_LOG_TABLE = table m := &XormDBAppender{} e, err := xorm.NewEngine(driver, spec) if err != nil { return nil, err } // config Engine e.SetTableMapper(core.SnakeMapper{}) e.SetColumnMapper(core.SameMapper{}) // Sync Table e.Sync(wlog.LogTable{}) m.Xorm = e m.BaseAppender = wlog.NewBaseAppender("db") return m, nil }
func init() { var err error engine, err = xorm.NewEngine("sqlite3", "./data.db") if err != nil { fmt.Println(err) return } engine.ShowSQL = true err = engine.CreateTables(su) if err != nil { fmt.Println(err) } else { cnt, err := engine.Count(su) if err != nil { fmt.Println(err) } else if cnt == 0 { user := User{1, "admin", "123"} _, err := engine.Insert(&user) if err != nil { fmt.Println(err) } else { fmt.Println("Init db successfully!") } } } }
func main() { f := "conversion.db" os.Remove(f) Orm, err := xorm.NewEngine("sqlite3", f) if err != nil { fmt.Println(err) return } Orm.ShowSQL(true) err = Orm.CreateTables(&User{}) if err != nil { fmt.Println(err) return } _, err = Orm.Insert(&User{1, "xlw", Registed}) if err != nil { fmt.Println(err) return } users := make([]User, 0) err = Orm.Find(&users) if err != nil { fmt.Println(err) return } fmt.Println(users) }
// DB is used to make connection to datbase . You can pass database type and its access information like // path to database or database name database user and database connection password . func DB() martini.Handler { /* * If you plan to use sqllite then make the following changes in config.ini * DbDriver = "sqlite3" * DbSource = "test.db" * * and import the sqllite driver * _ "github.com/mattn/go-sqlite3" * */ engine, err := xorm.NewEngine(conf.Setting.DbDriver, conf.Setting.DbSource) if err != nil { panic(err) } //engine.ShowSQL = true engine.Sync( &models.TestTable{}, ) return func(c martini.Context) { c.Map(engine) c.Next() } }
func initDB(config EnvConfig) { var err error mysqlserver := fmt.Sprintf("%v:%v@%v/%v?charset=utf8&parseTime=true", config.DB.User, config.DB.Password, config.DB.Server, config.DB.Dbname) x, err = xorm.NewEngine("mysql", mysqlserver) if err != nil { glog.V(1).Infof("Connect DataBase Fail:%v", err.Error()) } x.ShowSQL = true //打印SQL语句 //创建表 err = x.Sync2(new(Customer)) if err != nil { glog.V(1).Infof("Sync DataBase Fail:%v", err.Error()) } err = x.Sync2(new(Goods)) if err != nil { glog.V(1).Infof("Sync DataBase Fail:%v", err.Error()) } err = x.Sync2(new(Order)) if err != nil { glog.V(1).Infof("Sync DataBase Fail:%v", err.Error()) } }
func initDb() { var err error Engine, err = xorm.NewEngine("mysql", mysql_dsn) if err != nil { panic(err.Error()) // proper error handling instead of panic in your app } tbMapper := core.NewPrefixMapper(core.SnakeMapper{}, "pk_") Engine.SetTableMapper(tbMapper) Engine.ShowSQL = true //则会在控制台打印出生成的SQL语句; Engine.ShowDebug = true //则会在控制台打印调试信息; Engine.ShowErr = true //则会在控制台打印错误信息; Engine.ShowWarn = true //则会在控制台打印警告信息; f, err := os.Create("sql.log") if err != nil { println("error:") println(err.Error()) return } defer f.Close() Engine.Logger = xorm.NewSimpleLogger(f) // fmt.Println(Engine) }
func ExampleRegisterShardedDatabase() { engine1, _ = xorm.NewEngine("mysql", "root:@/example_user_a?charset=utf8") engine2, _ = xorm.NewEngine("mysql", "root:@/example_user_a?charset=utf8") engine3, _ = xorm.NewEngine("mysql", "root:@/example_user_b?charset=utf8") engine4, _ = xorm.NewEngine("mysql", "root:@/example_user_b?charset=utf8") w = wizard.NewWizard() shardClusters := w.CreateShardCluster(&User{}, 997) // create shard clusters for User{} with slotsize 997 standardClusterA := wizard.NewCluster(engine1) standardClusterA.RegisterSlave(engine2) shardClusters.RegisterShard(0, 500, standardClusterA) standardClusterB := wizard.NewCluster(engine3) standardClusterB.RegisterSlave(engine4) shardClusters.RegisterShard(501, 996, standardClusterB) }
func TestMysqlGonicMapper(t *testing.T) { err := mysqlDdlImport() if err != nil { t.Error(err) return } engine, err := xorm.NewEngine("mysql", "root:@/xorm_test1?charset=utf8") if err != nil { t.Error(err) return } defer engine.Close() engine.ShowSQL = ShowTestSql engine.ShowErr = ShowTestSql engine.ShowWarn = ShowTestSql engine.ShowDebug = ShowTestSql engine.SetMapper(core.GonicMapper{}) BaseTestAll(engine, t) //BaseTestAllSameMapper(engine, t) BaseTestAll2(engine, t) BaseTestAll3(engine, t) }
func TestMysqlWithCacheSameMapper(t *testing.T) { err := mysqlDdlImport() if err != nil { t.Error(err) return } engine, err := xorm.NewEngine("mysql", "root:@/xorm_test3?charset=utf8") if err != nil { t.Error(err) return } defer engine.Close() engine.SetMapper(core.SameMapper{}) engine.SetDefaultCacher(NewCacher()) engine.ShowSQL = ShowTestSql engine.ShowErr = ShowTestSql engine.ShowWarn = ShowTestSql engine.ShowDebug = ShowTestSql BaseTestAll(engine, t) BaseTestAllSameMapper(engine, t) BaseTestAll2(engine, t) }
func init() { var err error X, err = xorm.NewEngine("mssql", "server=.;database=goodsmanage;user id=sa;password=yiche2014") fmt.Println("-------11111") if err != nil { log.Fatalf("failt to carete engine") } fmt.Println("-------11111") X.SetMapper(core.SameMapper{}) //用户表 if err = X.Sync2(new(Tuser)); err != nil { log.Fatalf("failt Tuser to sync", err.Error()) } //菜单表 if err = X.Sync2(new(TMenus)); err != nil { log.Fatalf("failt TMenus to sync", err.Error()) } //角色表 if err = X.Sync2(new(TRoles)); err != nil { log.Fatalf("failt TRoles to sync", err.Error()) } //初始管理员 // var tuser = new(Tuser).Init() // var d = tuser.GetUser("admin") // if d == false { // _, _ = X.Exec("insert into [Tuser]([uname],password)values('admin','admin')") // } var tuser = new(Tuser).Init() if !tuser.Get(1) { _, _ = X.Exec("insert into [Tuser]([uname],password)values('admin','admin')") } }
func runSource(cmd *Command, args []string) { if len(args) != 2 { fmt.Println("params error, please see xorm help source") return } var err error engine, err = xorm.NewEngine(args[0], args[1]) if err != nil { fmt.Println(err) return } engine.ShowSQL, engine.ShowDebug = false, false engine.ShowErr, engine.ShowWarn = false, false err = engine.Ping() if err != nil { fmt.Println(err) return } _, err = engine.Import(os.Stdin) if err.Error() == "not an error" { err = nil } if err != nil { fmt.Println(err) return } }
func runDump(cmd *Command, args []string) { if len(args) != 2 { fmt.Println("params error, please see xorm help dump") return } var err error engine, err = xorm.NewEngine(args[0], args[1]) if err != nil { fmt.Println(err) return } engine.ShowSQL(false) engine.Logger().SetLevel(core.LOG_UNKNOWN) err = engine.Ping() if err != nil { fmt.Println(err) return } err = engine.DumpAll(os.Stdout) if err != nil { fmt.Println(err) return } }
func init() { c, err := goconfig.LoadConfigFile("conf/conf.ini") if err != nil { panic(err) } driver, err := c.GetValue("Database", "driver") if err != nil { panic(err) } dsn, err := c.GetValue("Database", "dsn") if err != nil { panic(err) } DataBase, err = xorm.NewEngine(driver, dsn) if err != nil { panic(err) } err = DataBase.Ping() if err != nil { panic(err) } }
func getEngine() (*xorm.Engine, error) { cnnstr := "" switch DbCfg.Type { case "mysql": if DbCfg.Host[0] == '/' { // looks like a unix socket cnnstr = fmt.Sprintf("%s:%s@unix(%s)/%s?charset=utf8", DbCfg.User, DbCfg.Passwd, DbCfg.Host, DbCfg.Name) } else { cnnstr = fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8", DbCfg.User, DbCfg.Passwd, DbCfg.Host, DbCfg.Name) } case "postgres": var host, port = "127.0.0.1", "5432" fields := strings.Split(DbCfg.Host, ":") if len(fields) > 0 && len(strings.TrimSpace(fields[0])) > 0 { host = fields[0] } if len(fields) > 1 && len(strings.TrimSpace(fields[1])) > 0 { port = fields[1] } cnnstr = fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s sslmode=%s", DbCfg.User, DbCfg.Passwd, host, port, DbCfg.Name, DbCfg.SSLMode) case "sqlite3": if !EnableSQLite3 { return nil, fmt.Errorf("Unknown database type: %s", DbCfg.Type) } os.MkdirAll(path.Dir(DbCfg.Path), os.ModePerm) cnnstr = "file:" + DbCfg.Path + "?cache=shared&mode=rwc" default: return nil, fmt.Errorf("Unknown database type: %s", DbCfg.Type) } return xorm.NewEngine(DbCfg.Type, cnnstr) }
func main() { f := "singleMapping.db" os.Remove(f) Orm, err := xorm.NewEngine("sqlite3", f) if err != nil { fmt.Println(err) return } Orm.ShowSQL = true err = Orm.CreateTables(&User{}, &LoginInfo{}) if err != nil { fmt.Println(err) return } _, err = Orm.Insert(&User{1, "xlw"}, &LoginInfo{1, "127.0.0.1", 1, "", 23}) if err != nil { fmt.Println(err) return } info := LoginInfo{} _, err = Orm.Id(1).Get(&info) if err != nil { fmt.Println(err) return } fmt.Println(info) }
//var engine *xorm.Engine func Update0508() { var err error engine, err = xorm.NewEngine("sqlite3", "./test.db") engine.SetMapper(core.SameMapper{}) if err != nil { fmt.Println(err) } cs := make([]Coordinate, 0) err = engine.Where("FormName='Frm05_8'").Find(&cs) if err != nil { fmt.Println(err) } ps := make([]PageProfile, 0) err = engine.Where("FormName='Frm05_8'").Find(&ps) if err != nil { fmt.Println(err) } for _, coor := range cs { cname := coor.CoordinateName for _, pro := range ps { pname := pro.ItemName_CN + pro.Display_CN if cname == pname { coor.CustomID = pro.CustomID _, err := engine.Id(coor.ID).Cols("CustomID").Update(&coor) if err != nil { fmt.Println(err) } } } } }
func getEngine() (*xorm.Engine, error) { LoadConfig() cnnstr := "" switch DbCfg.Type { case "mysql": cnnstr = fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8", DbCfg.User, DbCfg.Pwd, DbCfg.Host, DbCfg.Name) case "postgres": var host, port = "127.0.0.1", "5432" fields := strings.Split(DbCfg.Host, ":") if len(fields) > 0 && len(strings.TrimSpace(fields[0])) > 0 { host = fields[0] } if len(fields) > 1 && len(strings.TrimSpace(fields[1])) > 0 { port = fields[1] } cnnstr = fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s sslmode=%s", DbCfg.User, DbCfg.Pwd, host, port, DbCfg.Name, DbCfg.SslMode) case "sqlite3": if !filepath.IsAbs(DbCfg.Path) { DbCfg.Path = filepath.Join(setting.DataPath, DbCfg.Path) } os.MkdirAll(path.Dir(DbCfg.Path), os.ModePerm) cnnstr = "file:" + DbCfg.Path + "?cache=shared&mode=rwc&_loc=Local" default: return nil, fmt.Errorf("Unknown database type: %s", DbCfg.Type) } log.Info("Database: %v", DbCfg.Type) return xorm.NewEngine(DbCfg.Type, cnnstr) }
// NewXorm func NewXorm(conf *dbconf.DBConf) (*mdb.Xorm, error) { logger.Tracef("Create new mdb.Xorm, DB: %s ", conf.Database) // check args if conf == nil { return nil, fmt.Errorf("DBConf is nil") } engine, err := xorm.NewEngine("mysql", conf.GetMySqlConnURL()) if logger.CheckError(err) { return nil, err } // set engine default config //engine.ShowSQL = false //engine.ShowDebug = false //engine.ShowErr = true //engine.ShowWarn = false engine.SetTableMapper(core.SnakeMapper{}) //engine.SetColumnMapper(core.SnakeMapper{}) engine.SetColumnMapper(core.SameMapper{}) return mdb.NewXorm(engine), nil }
func (s *Sprint) Run() error { var err error dsn, _ := pq.ParseURL(os.Getenv("DATABASE_URL")) db, err := xorm.NewEngine("postgres", dsn) if err != nil { return err } err = db.Sync(Project{}) if err != nil { return err } s.Db = db s.Validator = validator.New(&validator.Config{TagName: "validate"}) port := os.Getenv("PORT") r := gin.Default() r.GET("/api/projects", s.GetProjects) r.GET("/api/projects/:id", s.GetProjectsOne) r.POST("/api/projects", s.CreateProjects) r.DELETE("/api/projects/:id", s.DeleteProjects) r.Run(":" + port) return nil }