func PrintTable(engine *xorm.Engine) {
var users []User
engine.Find(&users)
fmt.Printf("%+v\n", users)
}
func Crawl(engine *xorm.Engine) error {
latestIndices, err := getLatestIndices()
if err != nil {
return err
}
_, err = engine.Insert(&latestIndices.News)
if err != nil {
return err
}
news := make([]News, 0)
for _, newsIndex := range latestIndices.News {
content, err := getArticle(newsIndex.Id)
if err == nil {
news = append(news, News{newsIndex.Id, content})
}
}
_, err = engine.Insert(&news)
if err != nil {
return err
}
return nil
}
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":
x, err = xorm.NewEngine("postgres", fmt.Sprintf("user=%s password=%s dbname=%s sslmode=%s",
DbCfg.User, DbCfg.Pwd, DbCfg.Name, DbCfg.SslMode))
// case "sqlite3":
// 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(new(User), new(PublicKey), new(Repository), new(Watch),
new(Action), new(Access), new(Issue), new(Comment))
}
func main() {
var (
engine *xorm.Engine
user *User
)
engine = SetupDb()
//START CODE OMIT
engine.Insert(&User{Id: 1, FirstName: "John", LastName: "Doe"})
PrintTable(engine)
user = &User{Id: 1}
engine.Get(user)
user.FirstName = "James"
engine.Update(user)
PrintTable(engine)
engine.Delete(user)
PrintTable(engine)
//END CODE OMIT
}
func main() {
var (
engine *xorm.Engine
)
engine = SetupDb()
engine.Insert(&User{
Id: 1,
FirstName: "John",
LastName: "Doe",
Age: 24,
})
engine.Insert(&User{
Id: 2,
FirstName: "Jane",
LastName: "Doe",
Age: 52,
})
engine.Insert(&User{
Id: 3,
FirstName: "Joe",
LastName: "Shmoe",
Age: 10,
})
//START CODE OMIT
var users []User
engine.Where("last_name = ? OR age < ?", "Doe", "12").OrderBy("age").Limit(2).Find(&users)
fmt.Printf("%+v\n", users)
//END CODE OMIT
}
func test(engine *xorm.Engine) {
err := engine.CreateTables(u)
if err != nil {
fmt.Println(err)
return
}
size := 500
queue := make(chan int, size)
for i := 0; i < size; i++ {
go func(x int) {
//x := i
err := engine.Test()
if err != nil {
fmt.Println(err)
} else {
err = engine.Map(u)
if err != nil {
fmt.Println("Map user failed")
} else {
for j := 0; j < 10; j++ {
if x+j < 2 {
_, err = engine.Get(u)
} else if x+j < 4 {
users := make([]User, 0)
err = engine.Find(&users)
} else if x+j < 8 {
_, err = engine.Count(u)
} else if x+j < 16 {
_, err = engine.Insert(&User{Name: "xlw"})
} else if x+j < 32 {
_, err = engine.Id(1).Delete(u)
}
if err != nil {
fmt.Println(err)
queue <- x
return
}
}
fmt.Printf("%v success!\n", x)
}
}
queue <- x
}(i)
}
for i := 0; i < size; i++ {
<-queue
}
//conns := atomic.LoadInt32(&xorm.ConnectionNum)
//fmt.Println("connection number:", conns)
fmt.Println("end")
}
func main() {
//runtime.GOMAXPROCS(2)
// load config
var err error
cfg, err := config.Load("config.ini")
if err != nil {
fmt.Println(err)
return
}
cfgs := cfg.Map()
// create Orm
var orm *xorm.Engine
orm, err = xorm.NewEngine("mysql", fmt.Sprintf("%v:%v@%v/%v?charset=utf8",
cfgs["dbuser"], cfgs["dbpasswd"], cfgs["dbhost"], cfgs["dbname"]))
if err != nil {
fmt.Println(err)
return
}
orm.ShowSQL, _ = cfg.GetBool("showSql")
orm.ShowDebug, _ = cfg.GetBool("showDebug")
err = orm.Sync(&User{}, &Question{},
&QuestionFollow{}, &UserFollow{}, &Answer{}, &AnswerUp{},
&QuestionComment{}, &AnswerComment{}, &Tag{}, &QuestionTag{},
&Message{}, &Topic{}, &QuestionTopic{}, &TopicFollow{}, &News{})
if err != nil {
fmt.Println(err)
return
}
server := xweb.MainServer()
app := xweb.RootApp()
app.SetConfig("Orm", orm)
if useCache, _ := cfg.GetBool("useCache"); useCache {
server.Info("using orm cache system ...")
cacher := xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000)
orm.SetDefaultCacher(cacher)
}
// add actions
xweb.AddAction(&HomeAction{})
xweb.AutoAction(&ExerciseAction{}, &QuestionAction{}, &NewsAction{})
xweb.AddAction(&UserAction{})
// add login filter
loginFilter := xweb.NewLoginFilter(app, USER_ID_TAG, "/login")
loginFilter.AddAnonymousUrls("/", "/exercise", "/exercise/compile",
"/news", "/login", "/about", "/register")
app.AddFilter(loginFilter)
// add func or var app scope
app.AddTmplVar("AppVer", func() string {
return "v" + APP_VER
})
// run the web server
xweb.Run(fmt.Sprintf("%v:%v", cfgs["address"], cfgs["port"]))
}
func test(engine *xorm.Engine) {
err := engine.CreateTables(u)
if err != nil {
fmt.Println(err)
return
}
engine.ShowSQL = true
engine.Pool.SetMaxConns(5)
size := 1000
queue := make(chan int, size)
for i := 0; i < size; i++ {
go func(x int) {
//x := i
err := engine.Test()
if err != nil {
fmt.Println(err)
} else {
err = engine.Map(u)
if err != nil {
fmt.Println("Map user failed")
} else {
for j := 0; j < 10; j++ {
if x+j < 2 {
_, err = engine.Get(u)
} else if x+j < 4 {
users := make([]User, 0)
err = engine.Find(&users)
} else if x+j < 8 {
_, err = engine.Count(u)
} else if x+j < 16 {
_, err = engine.Insert(&User{Name: "xlw"})
} else if x+j < 32 {
_, err = engine.Id(1).Delete(u)
}
if err != nil {
fmt.Println(err)
queue <- x
return
}
}
fmt.Printf("%v success!\n", x)
}
}
queue <- x
}(i)
}
for i := 0; i < size; i++ {
<-queue
}
fmt.Println("end")
}
func sync(engine *xorm.Engine) error {
return engine.Sync(&SyncLoginInfo2{}, &SyncUser2{})
}