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 OpenDb(dbConf DbConf) *xorm.Engine { engine, err := xorm.NewEngine(DbUrl(dbConf)) if err != nil { log.Println(err) } //sql log engine.ShowSQL = dbConf.ShowSql engine.ShowErr = true engine.ShowWarn = true engine.SetMaxIdleConns(dbConf.MaxIdleConns) engine.SetMaxOpenConns(dbConf.MaxOpenConns) dbLog, err = os.Create("logs/db.log") if err != nil { log.Println("err:", err) } engine.Logger = xorm.NewSimpleLogger(dbLog) //init tx dbx.InitTx(engine) db = engine return engine }
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 SetEngine() (*xorm.Engine, error) { if engine, err := ConDb(); err != nil { return nil, err } else { engine.ShowInfo = false engine.ShowSQL = true //true则会在控制台打印出生成的SQL语句; engine.ShowDebug = true //true则会在控制台打印调试信息; engine.ShowWarn = true //true则会在控制台打印警告信息; engine.Logger.SetLevel(core.LOG_OFF) cacher := xorm.NewLRUCacher(xorm.NewMemoryStore(), 10000) engine.SetDefaultCacher(cacher) //engine.TZLocation = time.Local if f, err := os.Create("./logs/xorm.log"); err != nil { panic(fmt.Sprintf("Create Xorm Logs Error :%v", err)) } else { engine.Logger = xorm.NewSimpleLogger(f) } return engine, err } }
func SetEngine(engine *xorm.Engine, enableLog bool) (err error) { x = engine dialect = migrator.NewDialect(x.DriverName()) migrator := migrator.NewMigrator(x) migrator.LogLevel = 2 migrations.AddMigrations(migrator) if err := migrator.Start(); err != nil { return fmt.Errorf("Sqlstore::Migration failed err: %v\n", err) } if enableLog { logPath := path.Join("/tmp", "xorm.log") os.MkdirAll(path.Dir(logPath), os.ModePerm) f, err := os.Create(logPath) if err != nil { return fmt.Errorf("sqlstore.init(fail to create xorm.log): %v", err) } x.SetLogger(xorm.NewSimpleLogger(f)) x.ShowSQL(true) } return nil }
func CreateEngine(cfg *config.Config) (engine *xorm.Engine, err error) { x, err = getEngine(cfg) if err != nil { return nil, fmt.Errorf("Fail to connect to database: %v", err) } if cfg.Database.LogPath != "" { logPath := path.Join(cfg.Database.LogPath, "xorm.log") os.MkdirAll(path.Dir(logPath), os.ModePerm) file, err := os.Create(logPath) if err != nil { return nil, fmt.Errorf("Fail to create xorm.log file: %v", err) } x.SetLogger(xorm.NewSimpleLogger(file)) } x.ShowDebug = cfg.Database.ShowDebug x.ShowInfo = cfg.Database.ShowInfo x.ShowSQL = cfg.Database.ShowSQL x.ShowWarn = cfg.Database.ShowWarn x.ShowErr = cfg.Database.ShowErr // 如果有其他orm相关设置, 请直接设置即可 return x, nil }
func SetEngine() (err error) { x, err = getEngine() if err != nil { return fmt.Errorf("Fail to connect to database: %v", err) } x.SetMapper(core.GonicMapper{}) // WARNING: for serv command, MUST remove the output to os.stdout, // so use log file to instead print to stdout. logPath := path.Join( /*setting.LogRootPath*/ "log", "xorm.log") os.MkdirAll(path.Dir(logPath), os.ModePerm) f, err := os.Create(logPath) if err != nil { return fmt.Errorf("Fail to create xorm.log: %v", err) } x.SetLogger(xorm.NewSimpleLogger(f)) x.ShowSQL = true x.ShowInfo = true x.ShowDebug = true x.ShowErr = true x.ShowWarn = true return nil }
func SetEngine(engine *xorm.Engine, enableLog bool) (err error) { x = engine dialect = migrator.NewDialect(x.DriverName()) migrator := migrator.NewMigrator(x) migrator.LogLevel = log.INFO migrations.AddMigrations(migrator) if err := migrator.Start(); err != nil { return fmt.Errorf("Sqlstore::Migration failed err: %v\n", err) } if enableLog { logPath := path.Join(setting.LogsPath, "xorm.log") os.MkdirAll(path.Dir(logPath), os.ModePerm) f, err := os.Create(logPath) if err != nil { return fmt.Errorf("sqlstore.init(fail to create xorm.log): %v", err) } x.Logger = xorm.NewSimpleLogger(f) if setting.Env == setting.DEV { x.ShowSQL = false x.ShowInfo = false x.ShowDebug = false x.ShowErr = true x.ShowWarn = true } } return nil }
func newEngine(conf setting.DataBaseConfig) (*xorm.Engine, error) { cnnstr := "" switch conf.TYPE { case "mysql": if conf.HOST[0] == '/' { // looks like a unix socket cnnstr = fmt.Sprintf("%s:%s@unix(%s)/%s?charset=utf8", conf.USER, conf.PASSWD, conf.HOST, conf.DB) } else { cnnstr = fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8", conf.USER, conf.PASSWD, conf.HOST, conf.DB) } case "postgres": var host, port = "127.0.0.1", "5432" fields := strings.Split(conf.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", conf.USER, conf.PASSWD, host, port, conf.DB, conf.SSL_MODE) case "sqlite3": os.MkdirAll(path.Dir(conf.PATH), os.ModePerm) cnnstr = "file:" + conf.PATH + "?cache=shared&mode=rwc" default: return nil, fmt.Errorf("Unknown database type: %s", conf.TYPE) } x, err := xorm.NewEngine(conf.TYPE, cnnstr) if err != nil { return nil, err } // 连接池的空闲数大小 x.SetMaxIdleConns(conf.MaxIdle) // 最大打开连接数 x.SetMaxOpenConns(conf.MaxOpen) x.ShowSQL = true // 则会在控制台打印出生成的SQL语句; x.ShowDebug = true // 则会在控制台打印调试信息; x.ShowErr = true // 则会在控制台打印错误信息; x.ShowWarn = true // 则会在控制台打印警告信息; logpath, _ := filepath.Abs(conf.LogPath) os.MkdirAll(path.Dir(logpath), os.ModePerm) // 日志 f, err := os.Create(logpath) if err != nil { log.Error(4, "create xorm log file failed %v", err) return nil, err } // defer f.Close() x.Logger = xorm.NewSimpleLogger(f) return x, nil }
func init() { var err error mysqlEngine, err = xorm.NewEngine("mysql", "dasea:dasea@/dasea?charset=utf8") logger := xorm.NewSimpleLogger(os.Stdout) logger.SetLevel(core.LOG_OFF) mysqlEngine.SetLogger(logger) if err != nil { panic(err) } }
func init() { //获取服务器数据库相关信息 dbhost, _ := conf.Cfg.GetValue("db", "db_host") dbport, _ := conf.Cfg.GetValue("db", "db_port") dbuser, _ := conf.Cfg.GetValue("db", "db_user") dbpass, _ := conf.Cfg.GetValue("db", "db_pass") dbname, _ := conf.Cfg.GetValue("db", "db_name") dbIdle, _ := conf.Cfg.Int("db", "db_max_idle_conn") dbConn, _ := conf.Cfg.Int("db", "db_max_open_conn") dburl := dbuser + ":" + dbpass + "@tcp(" + dbhost + ":" + dbport + ")/" + dbname + "?charset=utf8" engine, err := xorm.NewEngine("mysql", dburl) if err != nil { log.Fatalf("数据库连接失败:%s", err) } //连接池空闲数和最大连接数 engine.SetMaxIdleConns(dbIdle) engine.SetMaxOpenConns(dbConn) //engine.Ping测试数据库连接 if err = engine.Ping(); err != nil { log.Fatalf("数据库连接失败:%s", err) os.Exit(1) } //同步数据结构 engine.Sync2(new(User)) runmode, _ := conf.Cfg.GetValue("", "runmode") if !strings.EqualFold(runmode, "dev") { // 输出sql到log var filelog string filelog = "log/xorm-sql-" + strings.Split(time.Now().String(), " ")[0] + ".log" f, err := os.OpenFile(filelog, os.O_WRONLY|os.O_CREATE, 0666) if err != nil { log.Fatalf("日志文件建立失败:%s", err) os.Exit(1) } engine.Logger = xorm.NewSimpleLogger(f) } //读取配置文件,设置xorm日志状态 showSQL, _ := conf.Cfg.GetValue("xorm", "showSql") showDebug, _ := conf.Cfg.GetValue("xorm", "showDebug") showError, _ := conf.Cfg.GetValue("xorm", "showError") showWarn, _ := conf.Cfg.GetValue("xorm", "showWarn") engine.ShowSQL = strings.EqualFold(showSQL, "true") engine.ShowDebug = strings.EqualFold(showDebug, "true") engine.ShowErr = strings.EqualFold(showError, "true") engine.ShowWarn = strings.EqualFold(showWarn, "true") Xorm = engine }
func main() { var err error engine, err = xorm.NewEngine("mysql", "root:123456@tcp(192.168.1.172:3306)/jc_test") 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 //则会在控制台打印警告信息; fmt.Println(err) // fmt.Println(engine.DBMetas()) // sql := "show tables" //results, err := engine.Query(sql) //fmt.Println(results) //fmt.Println(err) f, err := os.Create("sql.log") if err != nil { println(err.Error()) return } defer f.Close() engine.Logger = xorm.NewSimpleLogger(f) var odds_url = "http://odds.500.com/fenxi/yazhi-TTT.shtml" a := time.Now().Unix() - 86400 fmt.Println(a) yesday := time.Unix(a, 0).Format("2006-01-02") schs := make([]Schedule, 0) engine.Distinct("schedule_fid", "schedule_no", "schedule_date").Where("schedule_date = ?", yesday).Find(&schs) //fmt.Println(schs) for _, sch_info := range schs { fmt.Println(sch_info.ScheduleFid) fid := fmt.Sprintf("%d", sch_info.ScheduleFid) schedule_no := sch_info.ScheduleNo schedule_date := sch_info.ScheduleDate schedule_odds_url := strings.Replace(odds_url, "TTT", fid, -1) fmt.Println(schedule_odds_url) res := ParseOddUrl(schedule_odds_url, fid, schedule_no, schedule_date) fmt.Println(res) } }
func (s *Store) SetLogFile(path string) error { if path == "" { return nil } f, e := os.Create(path) if e != nil { return e } s.eng.Logger = xorm.NewSimpleLogger(f) s.eng.ShowSQL = true return nil }
// We cannot initialize xorm.Engine in init() function because Opts are // initialized in init function, and we cannot guarentee that Opts must be // initialized before any other init functions. So we intialize engine in main. // We must call meta.InitEngine in main before using it. func InitEngine(t string, hosts []string) { var err error //currently we only use one host, we will switch to using //2 alternatively in the future Engine, err = xorm.NewEngine(t, hosts[0]) logger := xorm.NewSimpleLogger(os.Stdout) logger.SetLevel(core.LOG_OFF) Engine.SetLogger(logger) if err != nil { panic(err) } }
func SetEngine() *xorm.Engine { Log.Info("db initializing...") var err error server := Cfg.MustValue("db", "server", "127.0.0.1") username := Cfg.MustValue("db", "username", "root") password := Cfg.MustValue("db", "password", "pass") dbName := Cfg.MustValue("db", "db_name", "go_display") orm, err = xorm.NewEngine("mysql", username+":"+password+"@tcp("+server+":3306)/"+dbName+"?charset=utf8") PanicIf(err) orm.TZLocation = time.Local orm.ShowSQL = Cfg.MustBool("db", "show_sql", false) orm.Logger = xorm.NewSimpleLogger(Log.GetWriter()) return orm }
func SetEngine() (err error) { switch DbCfg.Type { case "mysql": orm, 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 { host = fields[0] } if len(fields) > 1 { port = fields[1] } orm, err = xorm.NewEngine("postgres", 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": os.MkdirAll(path.Dir(DbCfg.Path), os.ModePerm) orm, 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) } // WARNNING: for serv command, MUST remove the output to os.stdout, // so use log file to instead print to stdout. execDir, _ := base.ExecDir() logPath := execDir + "/log/xorm.log" os.MkdirAll(path.Dir(logPath), os.ModePerm) f, err := os.Create(logPath) if err != nil { return fmt.Errorf("models.init(fail to create xorm.log): %v", err) } orm.Logger = xorm.NewSimpleLogger(f) orm.ShowSQL = true orm.ShowDebug = true orm.ShowErr = true return nil }
func main() { router := httprouter.New() router.ServeFiles("/js/*filepath", http.Dir("public/js")) router.ServeFiles("/css/*filepath", http.Dir("public/css")) router.ServeFiles("/bower_components/*filepath", http.Dir("public/bower_components")) router.GET("/", Index) router.GET("/user", UserGetHandler) router.POST("/user", UserPostHandler) // REST API for sfver router.GET("/sfvers", SfversGetHandler) router.POST("/sfvers", SfversPostHandler) go sfvTaskSchedule() var err error Engine, err = xorm.NewEngine("mysql", "test:1234@/sfver?charset=utf8") if err != nil { log.Fatal("database err:", err) } Engine.ShowDebug = true Engine.ShowErr = true Engine.ShowWarn = true Engine.ShowSQL = true f, err := os.Create("sql.log") if err != nil { log.Fatal("sql log create failed", err) } defer f.Close() Engine.Logger = xorm.NewSimpleLogger(f) err = Engine.Sync2(new(sfv.Sfver)) if err != nil { log.Fatal("database sync failed", err) } // Engine.DropTables("sfver") sfverService = sfv.DefaultSfvService(Engine) log.Println("Listening at 8080 ...") log.Fatal(http.ListenAndServe(":8080", router)) }
func init() { // read configure Conf = ReadConf() // setup xorm var err error if DB, err = xorm.NewEngine(Conf["DB"], Conf["DSN"]); err != nil { panic(err.Error()) } // set table prefix tbMapper := core.NewPrefixMapper(core.SnakeMapper{}, Conf["PREFIX"]) DB.SetTableMapper(tbMapper) // record sql DB.ShowSQL = true f, err := os.Create("sql.log") if err != nil { panic(err.Error()) } DB.Logger = xorm.NewSimpleLogger(f) }
func InitDb() { err := util.InitConf() if err != nil { return } err = initDb() if err != nil { log.Fatalf("Fail to create engine %v.", err) } engine.ShowSQL = false //则会在控制台打印出生成的SQL语句 engine.ShowDebug = false //则会在控制台打印调试信息; engine.ShowErr = true //则会在控制台打印错误信息; engine.ShowWarn = false //则会在控制台打印警告信息; f, err := os.Create("./logs/sql.log") if err != nil { fmt.Println(err.Error()) return } defer f.Close() engine.Logger = xorm.NewSimpleLogger(f) }
func SetEngine() (err error) { x, err = getEngine() if err != nil { return fmt.Errorf("models.init(fail to conntect database): %v", err) } // WARNNING: for serv command, MUST remove the output to os.stdout, // so use log file to instead print to stdout. logPath := path.Join(setting.LogRootPath, "xorm.log") os.MkdirAll(path.Dir(logPath), os.ModePerm) f, err := os.Create(logPath) if err != nil { return fmt.Errorf("models.init(fail to create xorm.log): %v", err) } x.Logger = xorm.NewSimpleLogger(f) x.ShowSQL = true x.ShowInfo = true x.ShowDebug = true x.ShowErr = true x.ShowWarn = true return nil }